mirror of
				https://github.com/jiawanlong/Cesium-Examples.git
				synced 2025-11-04 09:14:17 +00:00 
			
		
		
		
	
		
			
	
	
		
			480 lines
		
	
	
		
			20 KiB
		
	
	
	
		
			JavaScript
		
	
	
	
	
	
		
		
			
		
	
	
			480 lines
		
	
	
		
			20 KiB
		
	
	
	
		
			JavaScript
		
	
	
	
	
	
| 
								 | 
							
								
							 | 
						|||
| 
								 | 
							
								class ViewShed3D2 {
							 | 
						|||
| 
								 | 
							
								    enabled = true;
							 | 
						|||
| 
								 | 
							
								
							 | 
						|||
| 
								 | 
							
								    size = 2048;
							 | 
						|||
| 
								 | 
							
								
							 | 
						|||
| 
								 | 
							
								    softShadows = true;
							 | 
						|||
| 
								 | 
							
								
							 | 
						|||
| 
								 | 
							
								    constructor(options) {
							 | 
						|||
| 
								 | 
							
								        // TODO: viewer改成_viewer viewPosition改成_viewPosition direction改成_direction
							 | 
						|||
| 
								 | 
							
								        // TODO: pitch改成_pitch horizontalViewAngle改成_horizontalViewAngle verticalViewAngle改成_verticalViewAngle
							 | 
						|||
| 
								 | 
							
								        // TODO: visibleAreaColor改成_visibleAreaColor invisibleAreaColor改成_invisibleAreaColor visualRange改成_visualRange
							 | 
						|||
| 
								 | 
							
								        this.__v_skip = 1
							 | 
						|||
| 
								 | 
							
								        this.viewer = options.viewer;
							 | 
						|||
| 
								 | 
							
								        this.viewPosition = options.viewPosition;
							 | 
						|||
| 
								 | 
							
								        this.direction = options.direction % 360;
							 | 
						|||
| 
								 | 
							
								        this.pitch = options.pitch || 0;
							 | 
						|||
| 
								 | 
							
								        this.horizontalViewAngle = options.horizontalViewAngle || 90;
							 | 
						|||
| 
								 | 
							
								        this.verticalViewAngle = options.verticalViewAngle || 90;
							 | 
						|||
| 
								 | 
							
								        this.visibleAreaColor = options.visibleAreaColor || Cesium.Color.GREEN;
							 | 
						|||
| 
								 | 
							
								        this.invisibleAreaColor = options.invisibleAreaColor || Cesium.Color.RED;
							 | 
						|||
| 
								 | 
							
								        this.visualRange = options.visualRange || 100;
							 | 
						|||
| 
								 | 
							
								        this.updateViewShed();
							 | 
						|||
| 
								 | 
							
								    }
							 | 
						|||
| 
								 | 
							
								    // TODO: createLightCamera改成_createLightCamera 
							 | 
						|||
| 
								 | 
							
								    createLightCamera() {
							 | 
						|||
| 
								 | 
							
								        this.lightCamera = new Cesium.Camera(this.viewer.scene);
							 | 
						|||
| 
								 | 
							
								        this.lightCamera.position = this.viewPosition;
							 | 
						|||
| 
								 | 
							
								    }
							 | 
						|||
| 
								 | 
							
								
							 | 
						|||
| 
								 | 
							
								    // 以自定义相机为点光源,声明自定义shadowmap
							 | 
						|||
| 
								 | 
							
								    // 注意:虽然cesium并不建议修改shadowMap,但是必须将当前场景里的shadowMap替换为自定义的shadowMap,才能得到正确的参数。
							 | 
						|||
| 
								 | 
							
								    // TODO: createShadowMap改成_createShadowMap 
							 | 
						|||
| 
								 | 
							
								    createShadowMap() {
							 | 
						|||
| 
								 | 
							
								        this.shadowMap = new Cesium.ShadowMap({
							 | 
						|||
| 
								 | 
							
								            context: (this.viewer.scene).context,
							 | 
						|||
| 
								 | 
							
								            lightCamera: this.lightCamera,
							 | 
						|||
| 
								 | 
							
								            enabled: this.enabled,
							 | 
						|||
| 
								 | 
							
								            isPointLight: true,
							 | 
						|||
| 
								 | 
							
								            pointLightRadius: this.visualRange,
							 | 
						|||
| 
								 | 
							
								            cascadesEnabled: false,
							 | 
						|||
| 
								 | 
							
								            size: this.size,
							 | 
						|||
| 
								 | 
							
								            softShadows: this.softShadows,
							 | 
						|||
| 
								 | 
							
								            normalOffset: false,
							 | 
						|||
| 
								 | 
							
								            fromLightSource: false,
							 | 
						|||
| 
								 | 
							
								        });
							 | 
						|||
| 
								 | 
							
								        this.viewer.scene.shadowMap = this.shadowMap;
							 | 
						|||
| 
								 | 
							
								        this.viewer.scene.globe.shadows = Cesium.ShadowMode.ENABLED;
							 | 
						|||
| 
								 | 
							
								        this.viewer.scene.globe.depthTestAgainstTerrain = true;
							 | 
						|||
| 
								 | 
							
								    }
							 | 
						|||
| 
								 | 
							
								    // TODO: updateViewShed改成_updateViewShed 
							 | 
						|||
| 
								 | 
							
								    updateViewShed() {
							 | 
						|||
| 
								 | 
							
								        this.clear();
							 | 
						|||
| 
								 | 
							
								        this.createLightCamera();
							 | 
						|||
| 
								 | 
							
								        this.setCameraParams();
							 | 
						|||
| 
								 | 
							
								        this.createShadowMap();
							 | 
						|||
| 
								 | 
							
								        this.drawSketch()
							 | 
						|||
| 
								 | 
							
								        this.createPostStage();
							 | 
						|||
| 
								 | 
							
								        if (this.horizontalViewAngle < 180) {
							 | 
						|||
| 
								 | 
							
								            this.drawViewCentrum();
							 | 
						|||
| 
								 | 
							
								        }
							 | 
						|||
| 
								 | 
							
								    }
							 | 
						|||
| 
								 | 
							
								    // TODO: drawSketch改成_drawSketch 
							 | 
						|||
| 
								 | 
							
								    drawSketch() {
							 | 
						|||
| 
								 | 
							
								        if (this.sketch) {
							 | 
						|||
| 
								 | 
							
								            this.viewer.entities.remove(this.sketch)
							 | 
						|||
| 
								 | 
							
								        }
							 | 
						|||
| 
								 | 
							
								        this.sketch = this.viewer.entities.add({
							 | 
						|||
| 
								 | 
							
								            name: 'sketch',
							 | 
						|||
| 
								 | 
							
								            position: this.viewPosition,
							 | 
						|||
| 
								 | 
							
								            orientation: Cesium.Transforms.headingPitchRollQuaternion(
							 | 
						|||
| 
								 | 
							
								                this.viewPosition,
							 | 
						|||
| 
								 | 
							
								                Cesium.HeadingPitchRoll.fromDegrees(this.direction - 90, this.pitch, 0.0)
							 | 
						|||
| 
								 | 
							
								            ),
							 | 
						|||
| 
								 | 
							
								            ellipsoid: {
							 | 
						|||
| 
								 | 
							
								                radii: new Cesium.Cartesian3(
							 | 
						|||
| 
								 | 
							
								                    this.visualRange,
							 | 
						|||
| 
								 | 
							
								                    this.visualRange,
							 | 
						|||
| 
								 | 
							
								                    this.visualRange
							 | 
						|||
| 
								 | 
							
								                ),
							 | 
						|||
| 
								 | 
							
								                // innerRadii: new Cesium.Cartesian3(2.0, 2.0, 2.0),
							 | 
						|||
| 
								 | 
							
								                minimumClock: Cesium.Math.toRadians(-this.horizontalViewAngle / 2),
							 | 
						|||
| 
								 | 
							
								                maximumClock: Cesium.Math.toRadians(this.horizontalViewAngle / 2),
							 | 
						|||
| 
								 | 
							
								                minimumCone: Cesium.Math.toRadians(-this.verticalViewAngle / 2 + 90),
							 | 
						|||
| 
								 | 
							
								                maximumCone: Cesium.Math.toRadians(this.verticalViewAngle / 2 + 90),
							 | 
						|||
| 
								 | 
							
								                fill: false,
							 | 
						|||
| 
								 | 
							
								                outline: true,
							 | 
						|||
| 
								 | 
							
								                subdivisions: 256,
							 | 
						|||
| 
								 | 
							
								                stackPartitions: 64,
							 | 
						|||
| 
								 | 
							
								                slicePartitions: 64,
							 | 
						|||
| 
								 | 
							
								                outlineColor: Cesium.Color.YELLOWGREEN
							 | 
						|||
| 
								 | 
							
								            }
							 | 
						|||
| 
								 | 
							
								        });
							 | 
						|||
| 
								 | 
							
								    }
							 | 
						|||
| 
								 | 
							
								    // 视锥体
							 | 
						|||
| 
								 | 
							
								    // TODO: drawViewCentrum改成_drawViewCentrum 
							 | 
						|||
| 
								 | 
							
								    drawViewCentrum() {
							 | 
						|||
| 
								 | 
							
								        const scratchRight = new Cesium.Cartesian3();
							 | 
						|||
| 
								 | 
							
								        const scratchRotation = new Cesium.Matrix3();
							 | 
						|||
| 
								 | 
							
								        const scratchOrientation = new Cesium.Quaternion();
							 | 
						|||
| 
								 | 
							
								        const direction = this.lightCamera.directionWC;
							 | 
						|||
| 
								 | 
							
								        const up = this.lightCamera.upWC;
							 | 
						|||
| 
								 | 
							
								        let right = this.lightCamera.rightWC;
							 | 
						|||
| 
								 | 
							
								        right = Cesium.Cartesian3.negate(right, scratchRight);
							 | 
						|||
| 
								 | 
							
								
							 | 
						|||
| 
								 | 
							
								        const rotation = scratchRotation;
							 | 
						|||
| 
								 | 
							
								        Cesium.Matrix3.setColumn(rotation, 0, right, rotation);
							 | 
						|||
| 
								 | 
							
								        Cesium.Matrix3.setColumn(rotation, 1, up, rotation);
							 | 
						|||
| 
								 | 
							
								        Cesium.Matrix3.setColumn(rotation, 2, direction, rotation);
							 | 
						|||
| 
								 | 
							
								
							 | 
						|||
| 
								 | 
							
								        const orientation = Cesium.Quaternion.fromRotationMatrix(
							 | 
						|||
| 
								 | 
							
								            rotation,
							 | 
						|||
| 
								 | 
							
								            scratchOrientation,
							 | 
						|||
| 
								 | 
							
								        );
							 | 
						|||
| 
								 | 
							
								        const instanceOutline = new Cesium.GeometryInstance({
							 | 
						|||
| 
								 | 
							
								            geometry: new Cesium.FrustumOutlineGeometry({
							 | 
						|||
| 
								 | 
							
								                frustum: this.lightCamera.frustum,
							 | 
						|||
| 
								 | 
							
								                origin: this.viewPosition,
							 | 
						|||
| 
								 | 
							
								                orientation,
							 | 
						|||
| 
								 | 
							
								            }),
							 | 
						|||
| 
								 | 
							
								            id: `pri${this.viewer.scene.primitives.length + 1}`,
							 | 
						|||
| 
								 | 
							
								            attributes: {
							 | 
						|||
| 
								 | 
							
								                color: Cesium.ColorGeometryInstanceAttribute.fromColor(
							 | 
						|||
| 
								 | 
							
								                    new Cesium.Color(0.0, 1.0, 0.0, 1.0),
							 | 
						|||
| 
								 | 
							
								                ),
							 | 
						|||
| 
								 | 
							
								                show: new Cesium.ShowGeometryInstanceAttribute(true),
							 | 
						|||
| 
								 | 
							
								            },
							 | 
						|||
| 
								 | 
							
								        });
							 | 
						|||
| 
								 | 
							
								        this.newPrimitive = this.viewer.scene.primitives.add(
							 | 
						|||
| 
								 | 
							
								            new Cesium.Primitive({
							 | 
						|||
| 
								 | 
							
								                geometryInstances: instanceOutline,
							 | 
						|||
| 
								 | 
							
								                appearance: new Cesium.PerInstanceColorAppearance({
							 | 
						|||
| 
								 | 
							
								                    flat: true,
							 | 
						|||
| 
								 | 
							
								                }),
							 | 
						|||
| 
								 | 
							
								            }),
							 | 
						|||
| 
								 | 
							
								        );
							 | 
						|||
| 
								 | 
							
								    }
							 | 
						|||
| 
								 | 
							
								
							 | 
						|||
| 
								 | 
							
								    // 在观察点自定义相机,设置相机的可视椎体范围,方向
							 | 
						|||
| 
								 | 
							
								    // TODO: setCameraParams改成_setCameraParams 
							 | 
						|||
| 
								 | 
							
								    setCameraParams() {
							 | 
						|||
| 
								 | 
							
								        this.lightCamera.frustum.near = 0.001 * this.visualRange;
							 | 
						|||
| 
								 | 
							
								        this.lightCamera.frustum.far = this.visualRange;
							 | 
						|||
| 
								 | 
							
								        this.lightCamera.frustum.fov = Cesium.Math.toRadians(Math.max(this.horizontalViewAngle, this.verticalViewAngle));
							 | 
						|||
| 
								 | 
							
								        this.lightCamera.frustum.aspectRatio = this.horizontalViewAngle / this.verticalViewAngle;
							 | 
						|||
| 
								 | 
							
								        this.lightCamera.setView({
							 | 
						|||
| 
								 | 
							
								            destination: this.viewPosition,
							 | 
						|||
| 
								 | 
							
								            orientation: {
							 | 
						|||
| 
								 | 
							
								                heading: Cesium.Math.toRadians(this.direction || 0),
							 | 
						|||
| 
								 | 
							
								                pitch: Cesium.Math.toRadians(this.pitch || 0),
							 | 
						|||
| 
								 | 
							
								                roll: 0,
							 | 
						|||
| 
								 | 
							
								            },
							 | 
						|||
| 
								 | 
							
								        });
							 | 
						|||
| 
								 | 
							
								    }
							 | 
						|||
| 
								 | 
							
								
							 | 
						|||
| 
								 | 
							
								    clear() {
							 | 
						|||
| 
								 | 
							
								        // 椭球体
							 | 
						|||
| 
								 | 
							
								        if (this.pyramid) {
							 | 
						|||
| 
								 | 
							
								            this.viewer.entities.removeById(this.pyramid.id);
							 | 
						|||
| 
								 | 
							
								            this.pyramid = null;
							 | 
						|||
| 
								 | 
							
								        }
							 | 
						|||
| 
								 | 
							
								
							 | 
						|||
| 
								 | 
							
								        if (this.cameraPrimitive) {
							 | 
						|||
| 
								 | 
							
								            this.cameraPrimitive.destroy();
							 | 
						|||
| 
								 | 
							
								            this.cameraPrimitive = null;
							 | 
						|||
| 
								 | 
							
								        }
							 | 
						|||
| 
								 | 
							
								        // 煊染结果
							 | 
						|||
| 
								 | 
							
								        if (this.postStage) {
							 | 
						|||
| 
								 | 
							
								            this.viewer.scene.postProcessStages.remove(this.postStage);
							 | 
						|||
| 
								 | 
							
								            this.postStage = null;
							 | 
						|||
| 
								 | 
							
								        }
							 | 
						|||
| 
								 | 
							
								
							 | 
						|||
| 
								 | 
							
								        // 视锥体
							 | 
						|||
| 
								 | 
							
								        if (this.newPrimitive) {
							 | 
						|||
| 
								 | 
							
								            this.viewer.scene.primitives.remove(this.newPrimitive);
							 | 
						|||
| 
								 | 
							
								            this.newPrimitive = null;
							 | 
						|||
| 
								 | 
							
								        }
							 | 
						|||
| 
								 | 
							
								        if (this.sketch) {
							 | 
						|||
| 
								 | 
							
								            this.viewer.entities.remove(this.sketch)
							 | 
						|||
| 
								 | 
							
								        }
							 | 
						|||
| 
								 | 
							
								    }
							 | 
						|||
| 
								 | 
							
								
							 | 
						|||
| 
								 | 
							
								    // TODO: setDirection改成_setDirection 
							 | 
						|||
| 
								 | 
							
								    setDirection(direction) {
							 | 
						|||
| 
								 | 
							
								        this.direction = direction % 360;
							 | 
						|||
| 
								 | 
							
								        this.updateViewShed();
							 | 
						|||
| 
								 | 
							
								    }
							 | 
						|||
| 
								 | 
							
								
							 | 
						|||
| 
								 | 
							
								    // TODO: setPitch改成_setPitch 
							 | 
						|||
| 
								 | 
							
								    setPitch(pitch) {
							 | 
						|||
| 
								 | 
							
								        this.pitch = pitch;
							 | 
						|||
| 
								 | 
							
								        this.updateViewShed();
							 | 
						|||
| 
								 | 
							
								    }
							 | 
						|||
| 
								 | 
							
								    // TODO: setDirectionDistancePitch改成_setDirectionDistancePitch 
							 | 
						|||
| 
								 | 
							
								    setDirectionDistancePitch(direction, distance, pitch) {
							 | 
						|||
| 
								 | 
							
								        this.direction = direction % 360;
							 | 
						|||
| 
								 | 
							
								        this.visualRange = distance;
							 | 
						|||
| 
								 | 
							
								        this.pitch = pitch || 0;
							 | 
						|||
| 
								 | 
							
								        this.updateViewShed();
							 | 
						|||
| 
								 | 
							
								    }
							 | 
						|||
| 
								 | 
							
								    // TODO: setVisualRange改成_setVisualRange 
							 | 
						|||
| 
								 | 
							
								    setVisualRange(visualRange) {
							 | 
						|||
| 
								 | 
							
								        this.visualRange = visualRange;
							 | 
						|||
| 
								 | 
							
								        this.updateViewShed();
							 | 
						|||
| 
								 | 
							
								    }
							 | 
						|||
| 
								 | 
							
								
							 | 
						|||
| 
								 | 
							
								    // TODO: setHorizontalViewAngle改成_setHorizontalViewAngle 
							 | 
						|||
| 
								 | 
							
								    setHorizontalViewAngle(hva) {
							 | 
						|||
| 
								 | 
							
								        this.horizontalViewAngle = hva;
							 | 
						|||
| 
								 | 
							
								        this.updateViewShed();
							 | 
						|||
| 
								 | 
							
								    }
							 | 
						|||
| 
								 | 
							
								
							 | 
						|||
| 
								 | 
							
								    // TODO: setVerticalViewAngle改成_setVerticalViewAngle 
							 | 
						|||
| 
								 | 
							
								    setVerticalViewAngle(vva) {
							 | 
						|||
| 
								 | 
							
								        this.verticalViewAngle = vva;
							 | 
						|||
| 
								 | 
							
								        this.updateViewShed();
							 | 
						|||
| 
								 | 
							
								    }
							 | 
						|||
| 
								 | 
							
								
							 | 
						|||
| 
								 | 
							
								    // 根据shadowMap中的数据,实现自定义shader
							 | 
						|||
| 
								 | 
							
								    /*
							 | 
						|||
| 
								 | 
							
								       shader中的内容主要是从cesium源码中获取的,这只是简单实现了可视区域和不可视区域不同着色;
							 | 
						|||
| 
								 | 
							
								       如果要解决锯齿等问题,需要设置softShadows 、normalOffset 等,相应的glsl代码可以在源码Source\Scene\ShadowMapShader.js寻找;
							 | 
						|||
| 
								 | 
							
								       如果要实现可视区域、不可视区域颜色自由改变,只需要将v_color与inv_color两个变量改为外部传入就可以了。
							 | 
						|||
| 
								 | 
							
								     */
							 | 
						|||
| 
								 | 
							
								    // TODO: createPostStage改成_createPostStage 
							 | 
						|||
| 
								 | 
							
								    createPostStage() {
							 | 
						|||
| 
								 | 
							
								        const fs = `
							 | 
						|||
| 
								 | 
							
								    #define USE_CUBE_MAP_SHADOW true
							 | 
						|||
| 
								 | 
							
								    uniform sampler2D colorTexture;
							 | 
						|||
| 
								 | 
							
								    // 深度纹理
							 | 
						|||
| 
								 | 
							
								    uniform sampler2D depthTexture;
							 | 
						|||
| 
								 | 
							
								    // 纹理坐标
							 | 
						|||
| 
								 | 
							
								    in vec2 v_textureCoordinates;
							 | 
						|||
| 
								 | 
							
								
							 | 
						|||
| 
								 | 
							
								    uniform mat4 camera_projection_matrix;
							 | 
						|||
| 
								 | 
							
								
							 | 
						|||
| 
								 | 
							
								    uniform mat4 camera_view_matrix;
							 | 
						|||
| 
								 | 
							
								    // 观测距离
							 | 
						|||
| 
								 | 
							
								    uniform float far;
							 | 
						|||
| 
								 | 
							
								    //阴影
							 | 
						|||
| 
								 | 
							
								    uniform samplerCube shadowMap_textureCube;
							 | 
						|||
| 
								 | 
							
								
							 | 
						|||
| 
								 | 
							
								    uniform mat4 shadowMap_matrix;
							 | 
						|||
| 
								 | 
							
								    uniform vec4 shadowMap_lightPositionEC;
							 | 
						|||
| 
								 | 
							
								    uniform vec4 shadowMap_normalOffsetScaleDistanceMaxDistanceAndDarkness;
							 | 
						|||
| 
								 | 
							
								    uniform vec4 shadowMap_texelSizeDepthBiasAndNormalShadingSmooth;
							 | 
						|||
| 
								 | 
							
								
							 | 
						|||
| 
								 | 
							
								    struct zx_shadowParameters
							 | 
						|||
| 
								 | 
							
								    {
							 | 
						|||
| 
								 | 
							
								        vec3 texCoords;
							 | 
						|||
| 
								 | 
							
								        float depthBias;
							 | 
						|||
| 
								 | 
							
								        float depth;
							 | 
						|||
| 
								 | 
							
								        float nDotL;
							 | 
						|||
| 
								 | 
							
								        vec2 texelStepSize;
							 | 
						|||
| 
								 | 
							
								        float normalShadingSmooth;
							 | 
						|||
| 
								 | 
							
								        float darkness;
							 | 
						|||
| 
								 | 
							
								    };
							 | 
						|||
| 
								 | 
							
								
							 | 
						|||
| 
								 | 
							
								    vec3 uvwadd(vec3 uvw,vec2 tar)
							 | 
						|||
| 
								 | 
							
								    {
							 | 
						|||
| 
								 | 
							
								        vec2 temp=uvw.xy;
							 | 
						|||
| 
								 | 
							
								        float w=uvw.z;
							 | 
						|||
| 
								 | 
							
								        temp+=tar;
							 | 
						|||
| 
								 | 
							
								        return vec3(temp.x,temp.y,w);
							 | 
						|||
| 
								 | 
							
								    }
							 | 
						|||
| 
								 | 
							
								    float czm_shadowVisibility(samplerCube shadowMap, zx_shadowParameters shadowParameters)
							 | 
						|||
| 
								 | 
							
								    {
							 | 
						|||
| 
								 | 
							
								        float depthBias = shadowParameters.depthBias;
							 | 
						|||
| 
								 | 
							
								        float depth = shadowParameters.depth;
							 | 
						|||
| 
								 | 
							
								        float nDotL = shadowParameters.nDotL;
							 | 
						|||
| 
								 | 
							
								        float normalShadingSmooth = shadowParameters.normalShadingSmooth;
							 | 
						|||
| 
								 | 
							
								        float darkness = shadowParameters.darkness;
							 | 
						|||
| 
								 | 
							
								        vec3 uvw = shadowParameters.texCoords;
							 | 
						|||
| 
								 | 
							
								
							 | 
						|||
| 
								 | 
							
								        depth -= depthBias;
							 | 
						|||
| 
								 | 
							
								        vec2 texelStepSize = shadowParameters.texelStepSize;
							 | 
						|||
| 
								 | 
							
								        float radius = 1.0;
							 | 
						|||
| 
								 | 
							
								        float dx0 = -texelStepSize.x * radius;
							 | 
						|||
| 
								 | 
							
								        float dy0 = -texelStepSize.y * radius;
							 | 
						|||
| 
								 | 
							
								        float dx1 = texelStepSize.x * radius;
							 | 
						|||
| 
								 | 
							
								        float dy1 = texelStepSize.y * radius;
							 | 
						|||
| 
								 | 
							
								        float visibility = czm_shadowDepthCompare(shadowMap, uvw, depth);
							 | 
						|||
| 
								 | 
							
								        if(visibility==1.0)
							 | 
						|||
| 
								 | 
							
								          return 1.0;
							 | 
						|||
| 
								 | 
							
								        visibility=czm_shadowDepthCompare(shadowMap, uvwadd(uvw,vec2(dx0, dy0)), depth) +
							 | 
						|||
| 
								 | 
							
								        czm_shadowDepthCompare(shadowMap, uvwadd(uvw,vec2(0.0, dy0)), depth) +
							 | 
						|||
| 
								 | 
							
								        czm_shadowDepthCompare(shadowMap, uvwadd(uvw,vec2(dx1, dy0)), depth) +
							 | 
						|||
| 
								 | 
							
								        czm_shadowDepthCompare(shadowMap, uvwadd(uvw,vec2(dx0, 0.0)), depth) +
							 | 
						|||
| 
								 | 
							
								        czm_shadowDepthCompare(shadowMap, uvwadd(uvw,vec2(dx1, 0.0)), depth) +
							 | 
						|||
| 
								 | 
							
								        czm_shadowDepthCompare(shadowMap, uvwadd(uvw,vec2(0.0, dy1)), depth) +
							 | 
						|||
| 
								 | 
							
								        czm_shadowDepthCompare(shadowMap, uvwadd(uvw,vec2(dx0, dy1)), depth) +
							 | 
						|||
| 
								 | 
							
								        czm_shadowDepthCompare(shadowMap, uvwadd(uvw,vec2(dx1, dy1)), depth) ;
							 | 
						|||
| 
								 | 
							
								        if(visibility>=3.0)
							 | 
						|||
| 
								 | 
							
								          return 1.0;
							 | 
						|||
| 
								 | 
							
								        // float visibility =
							 | 
						|||
| 
								 | 
							
								        // (
							 | 
						|||
| 
								 | 
							
								        // czm_shadowDepthCompare(shadowMap, uvw, depth)
							 | 
						|||
| 
								 | 
							
								        // +czm_shadowDepthCompare(shadowMap, uvwadd(uvw,vec2(dx0, dy0)), depth) +
							 | 
						|||
| 
								 | 
							
								        // czm_shadowDepthCompare(shadowMap, uvwadd(uvwadd(uvw,vec2(dx0, dy0)),vec2(dx0, 0.0)), depth)+
							 | 
						|||
| 
								 | 
							
								        // czm_shadowDepthCompare(shadowMap, uvwadd(uvwadd(uvw,vec2(dx0, dy0)),vec2(dx0, dy0)), depth)+
							 | 
						|||
| 
								 | 
							
								        // czm_shadowDepthCompare(shadowMap, uvwadd(uvw,vec2(0.0, dy0)), depth) +
							 | 
						|||
| 
								 | 
							
								        // czm_shadowDepthCompare(shadowMap, uvwadd(uvwadd(uvw,vec2(0.0, dy0)),vec2(dx0,dy0)), depth)+
							 | 
						|||
| 
								 | 
							
								        // czm_shadowDepthCompare(shadowMap, uvwadd(uvwadd(uvw,vec2(0.0, dy0)),vec2(0.0, dy0)), depth)+
							 | 
						|||
| 
								 | 
							
								        // czm_shadowDepthCompare(shadowMap, uvwadd(uvw,vec2(dx1, dy0)), depth) +
							 | 
						|||
| 
								 | 
							
								        // czm_shadowDepthCompare(shadowMap, uvwadd(uvwadd(uvw,vec2(dx1, dy0)),vec2(dx1,dy0)), depth)+
							 | 
						|||
| 
								 | 
							
								        // czm_shadowDepthCompare(shadowMap, uvwadd(uvwadd(uvw,vec2(dx1, dy0)),vec2(0.0, dy0)), depth)+
							 | 
						|||
| 
								 | 
							
								        // czm_shadowDepthCompare(shadowMap, uvwadd(uvw,vec2(dx0, 0.0)), depth) +
							 | 
						|||
| 
								 | 
							
								        // czm_shadowDepthCompare(shadowMap, uvwadd(uvwadd(uvw,vec2(dx0, 0.0)),vec2(dx0,0.0)), depth)+
							 | 
						|||
| 
								 | 
							
								        // czm_shadowDepthCompare(shadowMap, uvwadd(uvwadd(uvw,vec2(dx0, 0.0)),vec2(dx0, dy0)), depth)+
							 | 
						|||
| 
								 | 
							
								        // czm_shadowDepthCompare(shadowMap, uvwadd(uvw,vec2(dx1, 0.0)), depth) +
							 | 
						|||
| 
								 | 
							
								        // czm_shadowDepthCompare(shadowMap, uvwadd(uvwadd(uvw,vec2(dx1, 0.0)),vec2(dx1, 0.0)), depth)+
							 | 
						|||
| 
								 | 
							
								        // czm_shadowDepthCompare(shadowMap, uvwadd(uvwadd(uvw,vec2(dx1, 0.0)),vec2(dx1, dy1)), depth)+
							 | 
						|||
| 
								 | 
							
								        // czm_shadowDepthCompare(shadowMap, uvwadd(uvw,vec2(0.0, dy1)), depth) +
							 | 
						|||
| 
								 | 
							
								        // czm_shadowDepthCompare(shadowMap, uvwadd(uvwadd(uvw,vec2(0.0, dy1)),vec2(0.0, dy1)), depth)+
							 | 
						|||
| 
								 | 
							
								        // czm_shadowDepthCompare(shadowMap, uvwadd(uvwadd(uvw,vec2(0.0, dy1)),vec2(dx1, dy1)), depth)+
							 | 
						|||
| 
								 | 
							
								        // czm_shadowDepthCompare(shadowMap, uvwadd(uvw,vec2(dx0, dy1)), depth) +
							 | 
						|||
| 
								 | 
							
								        // czm_shadowDepthCompare(shadowMap, uvwadd(uvwadd(uvw,vec2(dx0, dy1)),vec2(dx0, dy1)), depth)+
							 | 
						|||
| 
								 | 
							
								        // czm_shadowDepthCompare(shadowMap, uvwadd(uvwadd(uvw,vec2(dx0, dy1)),vec2(0.0, dy1)), depth)+
							 | 
						|||
| 
								 | 
							
								        // czm_shadowDepthCompare(shadowMap, uvwadd(uvw,vec2(dx1, dy1)), depth) +
							 | 
						|||
| 
								 | 
							
								        // czm_shadowDepthCompare(shadowMap, uvwadd(uvwadd(uvw,vec2(dx1, dy1)),vec2(dx1, dy1)), depth)+
							 | 
						|||
| 
								 | 
							
								        // czm_shadowDepthCompare(shadowMap, uvwadd(uvwadd(uvw,vec2(dx1, dy1)),vec2(dx1, 0.0)), depth)
							 | 
						|||
| 
								 | 
							
								        // ) * (1.0 /25.0)
							 | 
						|||
| 
								 | 
							
								        // ;
							 | 
						|||
| 
								 | 
							
								        return 0.0;
							 | 
						|||
| 
								 | 
							
								        // float visibility = czm_shadowDepthCompare(shadowMap, uvw, depth);
							 | 
						|||
| 
								 | 
							
								        // return czm_private_shadowVisibility(visibility, nDotL, normalShadingSmooth, darkness);
							 | 
						|||
| 
								 | 
							
								    }
							 | 
						|||
| 
								 | 
							
								
							 | 
						|||
| 
								 | 
							
								    vec4 getPositionEC(){
							 | 
						|||
| 
								 | 
							
								      return czm_windowToEyeCoordinates(gl_FragCoord);
							 | 
						|||
| 
								 | 
							
								    }
							 | 
						|||
| 
								 | 
							
								
							 | 
						|||
| 
								 | 
							
								    vec3 getNormalEC(){
							 | 
						|||
| 
								 | 
							
								      return vec3(1.);
							 | 
						|||
| 
								 | 
							
								    }
							 | 
						|||
| 
								 | 
							
								
							 | 
						|||
| 
								 | 
							
								    vec4 toEye(in vec2 uv,in float depth){
							 | 
						|||
| 
								 | 
							
								      vec2 xy=vec2((uv.x*2.-1.),(uv.y*2.-1.));
							 | 
						|||
| 
								 | 
							
								      vec4 posInCamera=czm_inverseProjection*vec4(xy,depth,1.);
							 | 
						|||
| 
								 | 
							
								      posInCamera=posInCamera/posInCamera.w;
							 | 
						|||
| 
								 | 
							
								      return posInCamera;
							 | 
						|||
| 
								 | 
							
								    }
							 | 
						|||
| 
								 | 
							
								
							 | 
						|||
| 
								 | 
							
								    vec3 pointProjectOnPlane(in vec3 planeNormal,in vec3 planeOrigin,in vec3 point){
							 | 
						|||
| 
								 | 
							
								      vec3 v01=point-planeOrigin;
							 | 
						|||
| 
								 | 
							
								      float d=dot(planeNormal,v01);
							 | 
						|||
| 
								 | 
							
								      return(point-planeNormal*d);
							 | 
						|||
| 
								 | 
							
								    }
							 | 
						|||
| 
								 | 
							
								
							 | 
						|||
| 
								 | 
							
								    float getDepth(in vec4 depth){
							 | 
						|||
| 
								 | 
							
								      float z_window=czm_unpackDepth(depth);
							 | 
						|||
| 
								 | 
							
								      z_window=czm_reverseLogDepth(z_window);
							 | 
						|||
| 
								 | 
							
								      float n_range=czm_depthRange.near;
							 | 
						|||
| 
								 | 
							
								      float f_range=czm_depthRange.far;
							 | 
						|||
| 
								 | 
							
								      return(2.*z_window-n_range-f_range)/(f_range-n_range);
							 | 
						|||
| 
								 | 
							
								    }
							 | 
						|||
| 
								 | 
							
								
							 | 
						|||
| 
								 | 
							
								    float shadow( in vec4 positionEC ){
							 | 
						|||
| 
								 | 
							
								      vec3 normalEC=getNormalEC();
							 | 
						|||
| 
								 | 
							
								      zx_shadowParameters shadowParameters;
							 | 
						|||
| 
								 | 
							
								      shadowParameters.texelStepSize=shadowMap_texelSizeDepthBiasAndNormalShadingSmooth.xy;
							 | 
						|||
| 
								 | 
							
								      shadowParameters.depthBias=shadowMap_texelSizeDepthBiasAndNormalShadingSmooth.z;
							 | 
						|||
| 
								 | 
							
								      shadowParameters.normalShadingSmooth=shadowMap_texelSizeDepthBiasAndNormalShadingSmooth.w;
							 | 
						|||
| 
								 | 
							
								      shadowParameters.darkness=shadowMap_normalOffsetScaleDistanceMaxDistanceAndDarkness.w;
							 | 
						|||
| 
								 | 
							
								      vec3 directionEC=positionEC.xyz-shadowMap_lightPositionEC.xyz;
							 | 
						|||
| 
								 | 
							
								      float distance=length(directionEC);
							 | 
						|||
| 
								 | 
							
								      directionEC=normalize(directionEC);
							 | 
						|||
| 
								 | 
							
								      float radius=shadowMap_lightPositionEC.w;
							 | 
						|||
| 
								 | 
							
								      if(distance>radius)
							 | 
						|||
| 
								 | 
							
								      {
							 | 
						|||
| 
								 | 
							
								        return 2.0;
							 | 
						|||
| 
								 | 
							
								      }
							 | 
						|||
| 
								 | 
							
								      vec3 directionWC=czm_inverseViewRotation*directionEC;
							 | 
						|||
| 
								 | 
							
								
							 | 
						|||
| 
								 | 
							
								      shadowParameters.depth=distance/radius-0.0003;
							 | 
						|||
| 
								 | 
							
								      shadowParameters.nDotL=clamp(dot(normalEC,-directionEC),0.,1.);
							 | 
						|||
| 
								 | 
							
								
							 | 
						|||
| 
								 | 
							
								      shadowParameters.texCoords=directionWC;
							 | 
						|||
| 
								 | 
							
								      float visibility=czm_shadowVisibility(shadowMap_textureCube,shadowParameters);
							 | 
						|||
| 
								 | 
							
								      return visibility;
							 | 
						|||
| 
								 | 
							
								    }
							 | 
						|||
| 
								 | 
							
								
							 | 
						|||
| 
								 | 
							
								    bool visible(in vec4 result)
							 | 
						|||
| 
								 | 
							
								    {
							 | 
						|||
| 
								 | 
							
								      result.x/=result.w;
							 | 
						|||
| 
								 | 
							
								      result.y/=result.w;
							 | 
						|||
| 
								 | 
							
								      result.z/=result.w;
							 | 
						|||
| 
								 | 
							
								      return result.x>=-1.&&result.x<=1.&&result.y>=-1.&&result.y<=1.&&result.z>=-1.&&result.z<=1.;
							 | 
						|||
| 
								 | 
							
								    }
							 | 
						|||
| 
								 | 
							
								    out vec4 fragColor;
							 | 
						|||
| 
								 | 
							
								    void main(){
							 | 
						|||
| 
								 | 
							
								      // 得到釉色 = 结构二维(彩色纹理,纹理坐标)
							 | 
						|||
| 
								 | 
							
								      fragColor=texture(colorTexture,v_textureCoordinates);
							 | 
						|||
| 
								 | 
							
								      // 深度 = (釉色 = 结构二维(深度纹理,纹理坐标))
							 | 
						|||
| 
								 | 
							
								      float depth=getDepth(texture(depthTexture,v_textureCoordinates));
							 | 
						|||
| 
								 | 
							
								      // 视角 = (纹理坐标,深度)
							 | 
						|||
| 
								 | 
							
								      vec4 viewPos=toEye(v_textureCoordinates,depth);
							 | 
						|||
| 
								 | 
							
								      //世界坐标
							 | 
						|||
| 
								 | 
							
								      vec4 wordPos=czm_inverseView*viewPos;
							 | 
						|||
| 
								 | 
							
								      // 虚拟相机中坐标
							 | 
						|||
| 
								 | 
							
								      vec4 vcPos=camera_view_matrix*wordPos;
							 | 
						|||
| 
								 | 
							
								      float near=.001*far;
							 | 
						|||
| 
								 | 
							
								      float dis=length(vcPos.xyz);
							 | 
						|||
| 
								 | 
							
								      if(dis>near&&dis<far){
							 | 
						|||
| 
								 | 
							
								        //透视投影
							 | 
						|||
| 
								 | 
							
								        vec4 posInEye=camera_projection_matrix*vcPos;
							 | 
						|||
| 
								 | 
							
								        // 可视区颜色
							 | 
						|||
| 
								 | 
							
								        vec4 v_color=vec4(0.,1.,0.,.5);
							 | 
						|||
| 
								 | 
							
								        vec4 inv_color=vec4(1.,0.,0.,.5);
							 | 
						|||
| 
								 | 
							
								        if(visible(posInEye)){
							 | 
						|||
| 
								 | 
							
								          float vis=shadow(viewPos);
							 | 
						|||
| 
								 | 
							
								          if(vis>=0.3){
							 | 
						|||
| 
								 | 
							
								            fragColor=mix(fragColor,vec4(0.,1.,0.0,.5),.5);
							 | 
						|||
| 
								 | 
							
								            // if(vis==(4.0/9.0))
							 | 
						|||
| 
								 | 
							
								            // {
							 | 
						|||
| 
								 | 
							
								            //     fragColor=vec4(0.,1.,1,.5);
							 | 
						|||
| 
								 | 
							
								            // }else if(vis==(5.0/9.0))
							 | 
						|||
| 
								 | 
							
								            // {
							 | 
						|||
| 
								 | 
							
								            //     fragColor=vec4(1.,1.,0.0,.5);
							 | 
						|||
| 
								 | 
							
								            // }else
							 | 
						|||
| 
								 | 
							
								            // {
							 | 
						|||
| 
								 | 
							
								            //     fragColor=mix(fragColor,v_color,.5);
							 | 
						|||
| 
								 | 
							
								            // }
							 | 
						|||
| 
								 | 
							
								          } else {
							 | 
						|||
| 
								 | 
							
								            fragColor=mix(fragColor,vec4(1.,0.,0.0,.5),.5);
							 | 
						|||
| 
								 | 
							
								          }
							 | 
						|||
| 
								 | 
							
								        }
							 | 
						|||
| 
								 | 
							
								      }
							 | 
						|||
| 
								 | 
							
								    }`;
							 | 
						|||
| 
								 | 
							
								        const postStage = new Cesium.PostProcessStage({
							 | 
						|||
| 
								 | 
							
								            fragmentShader: fs,
							 | 
						|||
| 
								 | 
							
								            uniforms: {
							 | 
						|||
| 
								 | 
							
								                camera_projection_matrix: this.lightCamera.frustum.projectionMatrix,
							 | 
						|||
| 
								 | 
							
								                camera_view_matrix: this.lightCamera.viewMatrix,
							 | 
						|||
| 
								 | 
							
								                far: () => this.visualRange,
							 | 
						|||
| 
								 | 
							
								                shadowMap_textureCube: () => {
							 | 
						|||
| 
								 | 
							
								                    this.shadowMap.update(Reflect.get(this.viewer.scene, '_frameState'));
							 | 
						|||
| 
								 | 
							
								                    return Reflect.get(this.shadowMap, '_shadowMapTexture');
							 | 
						|||
| 
								 | 
							
								                },
							 | 
						|||
| 
								 | 
							
								                shadowMap_matrix: () => {
							 | 
						|||
| 
								 | 
							
								                    this.shadowMap.update(Reflect.get(this.viewer.scene, '_frameState'));
							 | 
						|||
| 
								 | 
							
								                    return Reflect.get(this.shadowMap, '_shadowMapMatrix');
							 | 
						|||
| 
								 | 
							
								                },
							 | 
						|||
| 
								 | 
							
								                shadowMap_lightPositionEC: () => {
							 | 
						|||
| 
								 | 
							
								                    this.shadowMap.update(Reflect.get(this.viewer.scene, '_frameState'));
							 | 
						|||
| 
								 | 
							
								                    return Reflect.get(this.shadowMap, '_lightPositionEC');
							 | 
						|||
| 
								 | 
							
								                },
							 | 
						|||
| 
								 | 
							
								                shadowMap_normalOffsetScaleDistanceMaxDistanceAndDarkness: () => {
							 | 
						|||
| 
								 | 
							
								                    this.shadowMap.update(Reflect.get(this.viewer.scene, '_frameState'));
							 | 
						|||
| 
								 | 
							
								                    const bias = this.shadowMap._pointBias;
							 | 
						|||
| 
								 | 
							
								                    return Cesium.Cartesian4.fromElements(
							 | 
						|||
| 
								 | 
							
								                        bias.normalOffsetScale,
							 | 
						|||
| 
								 | 
							
								                        this.shadowMap._distance,
							 | 
						|||
| 
								 | 
							
								                        this.shadowMap.maximumDistance,
							 | 
						|||
| 
								 | 
							
								                        0.0,
							 | 
						|||
| 
								 | 
							
								                        new Cesium.Cartesian4(),
							 | 
						|||
| 
								 | 
							
								                    );
							 | 
						|||
| 
								 | 
							
								                },
							 | 
						|||
| 
								 | 
							
								                shadowMap_texelSizeDepthBiasAndNormalShadingSmooth: () => {
							 | 
						|||
| 
								 | 
							
								                    this.shadowMap.update(Reflect.get(this.viewer.scene, '_frameState'));
							 | 
						|||
| 
								 | 
							
								                    const bias = this.shadowMap._pointBias;
							 | 
						|||
| 
								 | 
							
								                    const scratchTexelStepSize = new Cesium.Cartesian2();
							 | 
						|||
| 
								 | 
							
								                    const texelStepSize = scratchTexelStepSize;
							 | 
						|||
| 
								 | 
							
								                    texelStepSize.x = 1.0 / this.shadowMap._textureSize.x;
							 | 
						|||
| 
								 | 
							
								                    texelStepSize.y = 1.0 / this.shadowMap._textureSize.y;
							 | 
						|||
| 
								 | 
							
								
							 | 
						|||
| 
								 | 
							
								                    return Cesium.Cartesian4.fromElements(
							 | 
						|||
| 
								 | 
							
								                        texelStepSize.x,
							 | 
						|||
| 
								 | 
							
								                        texelStepSize.y,
							 | 
						|||
| 
								 | 
							
								                        bias.depthBias,
							 | 
						|||
| 
								 | 
							
								                        bias.normalShadingSmooth,
							 | 
						|||
| 
								 | 
							
								                        new Cesium.Cartesian4(),
							 | 
						|||
| 
								 | 
							
								                    );
							 | 
						|||
| 
								 | 
							
								                },
							 | 
						|||
| 
								 | 
							
								            },
							 | 
						|||
| 
								 | 
							
								        });
							 | 
						|||
| 
								 | 
							
								        this.postStage = this.viewer.scene.postProcessStages.add(postStage);
							 | 
						|||
| 
								 | 
							
								    }
							 | 
						|||
| 
								 | 
							
								}
							 |