深度图

笔记.js

@@ -25,4 +25,305 @@ floor_location
 MeasurementLineMaterial : 测量线材质， 有蓝色标准实线和灰色透明虚线两种状态
 
 
+this.underlayScene.children[3] 包含32个子mesh， 是全景图sphere   其材质fragment在下方
+
+加载深度图loadDepthImage   获取深度值getDepth（用于更新reticule位置）。深度图用于修改全景图sphere的gl_FragDepthEXT
+
+
+
+
+
+
+=======shader=======
+全景图 fragment
+
+uniform sampler2D map;
+uniform float opacity;
+varying vec2 vUv;
+
+#ifdef USE_ALPHAMAP
+    uniform sampler2D alphaMap;
+#endif
+
+#ifdef GL_EXT_frag_depth
+    uniform sampler2D depthMap;
+    uniform mat4 inverseProjectionMatrix;
+    uniform mat4 projectionMatrix;
+    uniform vec4 viewport;
+#endif
+
+void main()
+{
+	vec4 color = texture2D(map, vUv);
+	float alpha = opacity;
+
+    #ifdef USE_ALPHAMAP
+        alpha *= texture2D(alphaMap, vUv).g;
+    #endif
+
+	gl_FragColor = vec4(color.r, color.g, color.b, alpha);
+
+    #ifdef GL_EXT_frag_depth
+
+        /*
+        * Useful resources:
+        *
+        * https://www.khronos.org/opengl/wiki/Vertex_Post-Processing#Viewport_transform
+        *   Clipping, perspective divide viewport transform
+        *
+        * https://www.khronos.org/opengl/wiki/Compute_eye_space_from_window_space
+        *   From window (viewport) space back to eye space in GLSL
+        *
+        * https://www.khronos.org/opengl/wiki/Vertex_Transformation
+        *   Summary of transformations object -> world -> eye (camera, view) -> clip -> NDC -> window
+        *
+        * http://slideplayer.com/slide/6837153/#
+        *   Overview presentation
+        *
+        * http://www.shaderific.com/glsl-variables/
+        *   GLSL built-in variables
+        */
+
+        vec4 depth = texture2D(depthMap, vUv);
+        //float distance = depth.r + 256. * (depth.g + 256. * depth.b);
+        //distance *= 255. * .001;           // distance is now in meters
+        
+        //更改
+        float distance = (depth.g + depth.r / 256.) * 255.;  //为什么要乘以255
+
+       // return  r[1] + r[0] / 256 
+
+
+        vec4 ndcPos;
+        ndcPos.xy = ((2.0 * gl_FragCoord.xy) - (2.0 * viewport.xy)) / (viewport.zw) - 1.;
+        ndcPos.z = (2.0 * gl_FragCoord.z - gl_DepthRange.near - gl_DepthRange.far) /
+            (gl_DepthRange.far - gl_DepthRange.near);
+        ndcPos.w = 1.0;
+
+        vec4 clipPos = ndcPos / gl_FragCoord.w;
+        vec4 eyePos = inverseProjectionMatrix * clipPos;
+
+        distance += .1;          // add a safety margin
+
+        vec4 eyePos2 = vec4(normalize(eyePos.xyz) * distance, 1.);
+        vec4 clipPos2 = projectionMatrix * eyePos2;
+        vec4 ndcPos2 = clipPos2 * 1. / clipPos2.w;
+
+        gl_FragDepthEXT = 0.5 * ((gl_DepthRange.far - gl_DepthRange.near) * ndcPos2.z
+                + gl_DepthRange.near + gl_DepthRange.far);
+
+    #endif
+
+}
+ 
+
+
+--------
+MeasurementLineMaterial vertex
+
+
+
+"attribute vec3 previous;
+attribute vec3 next;
+attribute float side;
+attribute float width;
+attribute float counters;
+
+uniform vec2 resolution;
+uniform float lineWidth;
+uniform vec3 color;
+uniform float opacity;
+uniform float near;
+uniform float far;
+uniform float sizeAttenuation;
+uniform vec3 dashColor;
+uniform float dashOpacity;
+
+varying vec2 vUV;
+varying vec4 vColor;
+varying vec4 vDashColor;
+varying float vCounters;
+
+vec2 fix(vec4 i, float aspect)
+{
+	vec2 res = i.xy / i.w;
+	res.x *= aspect;
+	vCounters = counters;
+	return res;
+}
+
+// This vertex shader is a copy of the one supplied by MeshLineMaterial.
+// It supports drawing dashed lines.
+void main()
+{
+	float aspect = resolution.x / resolution.y;
+	float pixelWidthRatio = 1.0 / (resolution.x * projectionMatrix[0][0]);
+
+	vColor = vec4(color, opacity);
+	vDashColor = vec4(dashColor, dashOpacity);
+	vUV = uv;
+
+	mat4 m = projectionMatrix * modelViewMatrix;
+	vec4 finalPosition = m * vec4(position, 1.0);
+	vec4 prevPos = m * vec4(previous, 1.0);
+	vec4 nextPos = m * vec4(next, 1.0);
+
+	vec2 currentP = fix(finalPosition, aspect);
+	vec2 prevP = fix(prevPos, aspect);
+	vec2 nextP = fix(nextPos, aspect);
+
+	float pixelWidth = finalPosition.w * pixelWidthRatio;
+	float w = 1.8 * pixelWidth * lineWidth * width;
+
+	if (sizeAttenuation == 1.0)
+	{
+		w = 1.8 * lineWidth * width;
+	}
+
+	vec2 dir;
+	if (nextP == currentP)
+	{
+		dir = normalize(currentP - prevP);
+	}
+	else if (prevP == currentP)
+	{
+		dir = normalize(nextP - currentP);
+	}
+	else
+	{
+		vec2 dir1 = normalize(currentP - prevP);
+		vec2 dir2 = normalize(nextP - currentP);
+		dir = normalize(dir1 + dir2);
+
+		vec2 perp = vec2(-dir1.y, dir1.x);
+		vec2 miter = vec2(-dir.y, dir.x);
+	}
+
+	vec2 normal = vec2(-dir.y, dir.x);
+	normal.x /= aspect;
+	normal *= .5 * w;
+
+	vec4 offset = vec4(normal * side, 0.0, 1.0);
+	finalPosition.xy += offset.xy;
+
+	gl_Position = finalPosition;
+}
+--------
+MeasurementLineMaterial fragment
+
+
+
+uniform sampler2D map;
+uniform sampler2D alphaMap;
+uniform float useMap;
+uniform float useAlphaMap;
+uniform float useDash;
+uniform float dashArray;
+uniform float dashOffset;
+uniform float dashRatio;
+uniform float visibility;
+uniform float alphaTest;
+uniform vec2 repeat;
+uniform sampler2D depthTexture;
+uniform sampler2D rgbaTexture;
+uniform float nearPlane;
+uniform float farPlane;
+uniform float occlusionDistance;
+uniform float clipDistance;
+uniform vec2 viewportSize;
+uniform vec2 viewportOffset;
+
+varying vec2 vUV;
+varying vec4 vColor;
+varying vec4 vDashColor;
+varying float vCounters;
+
+// Converts the exponential depth value from the depth buffer to a linear value
+// See https://learnopengl.com/Advanced-OpenGL/Depth-testing for more information about this formula
+float convertToLinear(float zValue)
+{
+	float z = zValue * 2.0 - 1.0;
+	return (2.0 * nearPlane * farPlane) / (farPlane + nearPlane - z * (farPlane - nearPlane));
+}
+
+void main()
+{
+	vec4 c = vDashColor;
+
+	// <-- The following section of the shader is copied from MeshLineMaterial
+
+	// Sample the fragment from a texture if such is supplied
+	if (useMap == 1.0)
+	{
+		c *= texture2D(map, vUV * repeat);
+	}
+
+	// Sample the fragment's alpha value from an alpha texture if such is supplied
+	if (useAlphaMap == 1.0)
+	{
+		c.a *= texture2D(alphaMap, vUV * repeat).a;
+	}
+
+	// Discard the fragment if below the alpha threshold
+	if (c.a < alphaTest)
+	{
+		discard;
+	}
+
+	// If the line is dashed, set the alpha value of the fragment according to the line segment it belongs to
+	if (useDash == 1.0)
+	{
+		c.a *= ceil(mod(vCounters + dashOffset, dashArray) - (dashArray * dashRatio));
+	}
+
+	// <-- end of copied code
+
+#ifdef GL_EXT_frag_depth
+	// mixFactor and clipFactor define the color mixing proportion between the states of
+	// full visibility and occluded visibility
+	// and
+	// full visibility and total invisibility
+	float mixFactor = 0.0;
+	float clipFactor = 0.0;
+
+	// The linear depth value of the current fragment
+	float fragDepth = convertToLinear(gl_FragCoord.z);
+
+	// The coordinates of the current fragment in the depth texture
+	vec2 depthTxtCoords = vec2(gl_FragCoord.x - viewportOffset.x, gl_FragCoord.y) / viewportSize;
+
+	// The linear depth value of the pixel occupied by this fragment in the depth buffer
+	float textureDepth = convertToLinear(texture2D(depthTexture, depthTxtCoords).r);
+
+	// The difference between the two depths
+	float delta = textureDepth - fragDepth;
+
+	if (delta < 0.0)
+	{
+		// occlusionDistance and clipDistance define the width of the respective zones and
+		// mixFactor and clipFactor express the interpolation between the two colors depending on the position
+		// of the current fragment withing those zones.
+		mixFactor = clamp(delta / occlusionDistance, 0.0, 1.0);
+		clipFactor = clamp(delta / clipDistance, 0.0, 1.0);
+	}
+	// If the fragment is totally transparent, don't bother drawing it
+	if (clipFactor == 1.0)
+	{
+		discard;
+	}
+#else
+	float mixFactor = 0.0;
+	float clipFactor = 0.0;
+#endif
+
+	// Calculate the color of the dashed version of the line
+	vec4 backColor = vec4(c.rgb, c.a * step(vCounters, visibility));
+
+	// Mix between the solid and the dahsed versions of the line according to the mixFactor
+	gl_FragColor = mix(vColor, backColor, mixFactor);
+
+	// Set the alpha value of the fragment according to the clipFactor
+	// Note that clipFactor was previously clamped [0.0;1.0]
+	gl_FragColor.a *= (1.0 - clipFactor);
+}