datasets中的orientation为模型整体绕z轴的旋转角度，初始为0


filter中的：

 

数据集校准后不变的值有：
dataset_orientation（永远存储最初始的点位的quaternion，在旋转时也不变，因此它等于没有旋转时的orientation）---- image.datasetOrientation
dataset_floor_orientation（一般和dataset_orientation值一样） 
dataset_location
dataset_floor_location



数据集校准后改变的值有：
orientation----image.orientation（在旋转时实时变，且是根据模型旋转度数和dataset_orientation来算的，所以如果dataset_orientation不对，就会算错。）
location----image.location
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);
}

