@cesium/engine 0.1.0

package/Source/Shaders/Builtin/Functions/vertexLogDepth.js

@@ -0,0 +1,66 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "#ifdef LOG_DEPTH\n\
+// 1.0 at the near plane, increasing linearly from there.\n\
+varying float v_depthFromNearPlusOne;\n\
+#ifdef SHADOW_MAP\n\
+varying vec3 v_logPositionEC;\n\
+#endif\n\
+#endif\n\
+\n\
+vec4 czm_updatePositionDepth(vec4 coords) {\n\
+#if defined(LOG_DEPTH)\n\
+\n\
+#ifdef SHADOW_MAP\n\
+    vec3 logPositionEC = (czm_inverseProjection * coords).xyz;\n\
+    v_logPositionEC = logPositionEC;\n\
+#endif\n\
+\n\
+    // With the very high far/near ratios used with the logarithmic depth\n\
+    // buffer, floating point rounding errors can cause linear depth values\n\
+    // to end up on the wrong side of the far plane, even for vertices that\n\
+    // are really nowhere near it. Since we always write a correct logarithmic\n\
+    // depth value in the fragment shader anyway, we just need to make sure\n\
+    // such errors don't cause the primitive to be clipped entirely before\n\
+    // we even get to the fragment shader.\n\
+    coords.z = clamp(coords.z / coords.w, -1.0, 1.0) * coords.w;\n\
+#endif\n\
+\n\
+    return coords;\n\
+}\n\
+\n\
+/**\n\
+ * Writes the logarithmic depth to gl_Position using the already computed gl_Position.\n\
+ *\n\
+ * @name czm_vertexLogDepth\n\
+ * @glslFunction\n\
+ */\n\
+void czm_vertexLogDepth()\n\
+{\n\
+#ifdef LOG_DEPTH\n\
+    v_depthFromNearPlusOne = (gl_Position.w - czm_currentFrustum.x) + 1.0;\n\
+    gl_Position = czm_updatePositionDepth(gl_Position);\n\
+#endif\n\
+}\n\
+\n\
+/**\n\
+ * Writes the logarithmic depth to gl_Position using the provided clip coordinates.\n\
+ * <p>\n\
+ * An example use case for this function would be moving the vertex in window coordinates\n\
+ * before converting back to clip coordinates. Use the original vertex clip coordinates.\n\
+ * </p>\n\
+ * @name czm_vertexLogDepth\n\
+ * @glslFunction\n\
+ *\n\
+ * @param {vec4} clipCoords The vertex in clip coordinates.\n\
+ *\n\
+ * @example\n\
+ * czm_vertexLogDepth(czm_projection * vec4(positionEyeCoordinates, 1.0));\n\
+ */\n\
+void czm_vertexLogDepth(vec4 clipCoords)\n\
+{\n\
+#ifdef LOG_DEPTH\n\
+    v_depthFromNearPlusOne = (clipCoords.w - czm_currentFrustum.x) + 1.0;\n\
+    czm_updatePositionDepth(clipCoords);\n\
+#endif\n\
+}\n\
+";

package/Source/Shaders/Builtin/Functions/windowToEyeCoordinates.glsl

@@ -0,0 +1,99 @@
+/**
+ * Transforms a position from window to eye coordinates.
+ * The transform from window to normalized device coordinates is done using components
+ * of (@link czm_viewport} and {@link czm_viewportTransformation} instead of calculating
+ * the inverse of <code>czm_viewportTransformation</code>. The transformation from
+ * normalized device coordinates to clip coordinates is done using <code>fragmentCoordinate.w</code>,
+ * which is expected to be the scalar used in the perspective divide. The transformation
+ * from clip to eye coordinates is done using {@link czm_inverseProjection}.
+ *
+ * @name czm_windowToEyeCoordinates
+ * @glslFunction
+ *
+ * @param {vec4} fragmentCoordinate The position in window coordinates to transform.
+ *
+ * @returns {vec4} The transformed position in eye coordinates.
+ *
+ * @see czm_modelToWindowCoordinates
+ * @see czm_eyeToWindowCoordinates
+ * @see czm_inverseProjection
+ * @see czm_viewport
+ * @see czm_viewportTransformation
+ *
+ * @example
+ * vec4 positionEC = czm_windowToEyeCoordinates(gl_FragCoord);
+ */
+vec4 czm_windowToEyeCoordinates(vec4 fragmentCoordinate)
+{
+    // Reconstruct NDC coordinates
+    float x = 2.0 * (fragmentCoordinate.x - czm_viewport.x) / czm_viewport.z - 1.0;
+    float y = 2.0 * (fragmentCoordinate.y - czm_viewport.y) / czm_viewport.w - 1.0;
+    float z = (fragmentCoordinate.z - czm_viewportTransformation[3][2]) / czm_viewportTransformation[2][2];
+    vec4 q = vec4(x, y, z, 1.0);
+
+    // Reverse the perspective division to obtain clip coordinates.
+    q /= fragmentCoordinate.w;
+
+    // Reverse the projection transformation to obtain eye coordinates.
+    if (!(czm_inverseProjection == mat4(0.0))) // IE and Edge sometimes do something weird with != between mat4s
+    {
+        q = czm_inverseProjection * q;
+    }
+    else
+    {
+        float top = czm_frustumPlanes.x;
+        float bottom = czm_frustumPlanes.y;
+        float left = czm_frustumPlanes.z;
+        float right = czm_frustumPlanes.w;
+
+        float near = czm_currentFrustum.x;
+        float far = czm_currentFrustum.y;
+
+        q.x = (q.x * (right - left) + left + right) * 0.5;
+        q.y = (q.y * (top - bottom) + bottom + top) * 0.5;
+        q.z = (q.z * (near - far) - near - far) * 0.5;
+        q.w = 1.0;
+    }
+
+    return q;
+}
+
+/**
+ * Transforms a position given as window x/y and a depth or a log depth from window to eye coordinates.
+ * This function produces more accurate results for window positions with log depth than
+ * conventionally unpacking the log depth using czm_reverseLogDepth and using the standard version
+ * of czm_windowToEyeCoordinates.
+ *
+ * @name czm_windowToEyeCoordinates
+ * @glslFunction
+ *
+ * @param {vec2} fragmentCoordinateXY The XY position in window coordinates to transform.
+ * @param {float} depthOrLogDepth A depth or log depth for the fragment.
+ *
+ * @see czm_modelToWindowCoordinates
+ * @see czm_eyeToWindowCoordinates
+ * @see czm_inverseProjection
+ * @see czm_viewport
+ * @see czm_viewportTransformation
+ *
+ * @returns {vec4} The transformed position in eye coordinates.
+ */
+vec4 czm_windowToEyeCoordinates(vec2 fragmentCoordinateXY, float depthOrLogDepth)
+{
+    // See reverseLogDepth.glsl. This is separate to re-use the pow.
+#ifdef LOG_DEPTH
+    float near = czm_currentFrustum.x;
+    float far = czm_currentFrustum.y;
+    float log2Depth = depthOrLogDepth * czm_log2FarDepthFromNearPlusOne;
+    float depthFromNear = pow(2.0, log2Depth) - 1.0;
+    float depthFromCamera = depthFromNear + near;
+    vec4 windowCoord = vec4(fragmentCoordinateXY, far * (1.0 - near / depthFromCamera) / (far - near), 1.0);
+    vec4 eyeCoordinate = czm_windowToEyeCoordinates(windowCoord);
+    eyeCoordinate.w = 1.0 / depthFromCamera; // Better precision
+    return eyeCoordinate;
+#else
+    vec4 windowCoord = vec4(fragmentCoordinateXY, depthOrLogDepth, 1.0);
+    vec4 eyeCoordinate = czm_windowToEyeCoordinates(windowCoord);
+#endif
+    return eyeCoordinate;
+}

package/Source/Shaders/Builtin/Functions/windowToEyeCoordinates.js

@@ -0,0 +1,101 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "/**\n\
+ * Transforms a position from window to eye coordinates.\n\
+ * The transform from window to normalized device coordinates is done using components\n\
+ * of (@link czm_viewport} and {@link czm_viewportTransformation} instead of calculating\n\
+ * the inverse of <code>czm_viewportTransformation</code>. The transformation from\n\
+ * normalized device coordinates to clip coordinates is done using <code>fragmentCoordinate.w</code>,\n\
+ * which is expected to be the scalar used in the perspective divide. The transformation\n\
+ * from clip to eye coordinates is done using {@link czm_inverseProjection}.\n\
+ *\n\
+ * @name czm_windowToEyeCoordinates\n\
+ * @glslFunction\n\
+ *\n\
+ * @param {vec4} fragmentCoordinate The position in window coordinates to transform.\n\
+ *\n\
+ * @returns {vec4} The transformed position in eye coordinates.\n\
+ *\n\
+ * @see czm_modelToWindowCoordinates\n\
+ * @see czm_eyeToWindowCoordinates\n\
+ * @see czm_inverseProjection\n\
+ * @see czm_viewport\n\
+ * @see czm_viewportTransformation\n\
+ *\n\
+ * @example\n\
+ * vec4 positionEC = czm_windowToEyeCoordinates(gl_FragCoord);\n\
+ */\n\
+vec4 czm_windowToEyeCoordinates(vec4 fragmentCoordinate)\n\
+{\n\
+    // Reconstruct NDC coordinates\n\
+    float x = 2.0 * (fragmentCoordinate.x - czm_viewport.x) / czm_viewport.z - 1.0;\n\
+    float y = 2.0 * (fragmentCoordinate.y - czm_viewport.y) / czm_viewport.w - 1.0;\n\
+    float z = (fragmentCoordinate.z - czm_viewportTransformation[3][2]) / czm_viewportTransformation[2][2];\n\
+    vec4 q = vec4(x, y, z, 1.0);\n\
+\n\
+    // Reverse the perspective division to obtain clip coordinates.\n\
+    q /= fragmentCoordinate.w;\n\
+\n\
+    // Reverse the projection transformation to obtain eye coordinates.\n\
+    if (!(czm_inverseProjection == mat4(0.0))) // IE and Edge sometimes do something weird with != between mat4s\n\
+    {\n\
+        q = czm_inverseProjection * q;\n\
+    }\n\
+    else\n\
+    {\n\
+        float top = czm_frustumPlanes.x;\n\
+        float bottom = czm_frustumPlanes.y;\n\
+        float left = czm_frustumPlanes.z;\n\
+        float right = czm_frustumPlanes.w;\n\
+\n\
+        float near = czm_currentFrustum.x;\n\
+        float far = czm_currentFrustum.y;\n\
+\n\
+        q.x = (q.x * (right - left) + left + right) * 0.5;\n\
+        q.y = (q.y * (top - bottom) + bottom + top) * 0.5;\n\
+        q.z = (q.z * (near - far) - near - far) * 0.5;\n\
+        q.w = 1.0;\n\
+    }\n\
+\n\
+    return q;\n\
+}\n\
+\n\
+/**\n\
+ * Transforms a position given as window x/y and a depth or a log depth from window to eye coordinates.\n\
+ * This function produces more accurate results for window positions with log depth than\n\
+ * conventionally unpacking the log depth using czm_reverseLogDepth and using the standard version\n\
+ * of czm_windowToEyeCoordinates.\n\
+ *\n\
+ * @name czm_windowToEyeCoordinates\n\
+ * @glslFunction\n\
+ *\n\
+ * @param {vec2} fragmentCoordinateXY The XY position in window coordinates to transform.\n\
+ * @param {float} depthOrLogDepth A depth or log depth for the fragment.\n\
+ *\n\
+ * @see czm_modelToWindowCoordinates\n\
+ * @see czm_eyeToWindowCoordinates\n\
+ * @see czm_inverseProjection\n\
+ * @see czm_viewport\n\
+ * @see czm_viewportTransformation\n\
+ *\n\
+ * @returns {vec4} The transformed position in eye coordinates.\n\
+ */\n\
+vec4 czm_windowToEyeCoordinates(vec2 fragmentCoordinateXY, float depthOrLogDepth)\n\
+{\n\
+    // See reverseLogDepth.glsl. This is separate to re-use the pow.\n\
+#ifdef LOG_DEPTH\n\
+    float near = czm_currentFrustum.x;\n\
+    float far = czm_currentFrustum.y;\n\
+    float log2Depth = depthOrLogDepth * czm_log2FarDepthFromNearPlusOne;\n\
+    float depthFromNear = pow(2.0, log2Depth) - 1.0;\n\
+    float depthFromCamera = depthFromNear + near;\n\
+    vec4 windowCoord = vec4(fragmentCoordinateXY, far * (1.0 - near / depthFromCamera) / (far - near), 1.0);\n\
+    vec4 eyeCoordinate = czm_windowToEyeCoordinates(windowCoord);\n\
+    eyeCoordinate.w = 1.0 / depthFromCamera; // Better precision\n\
+    return eyeCoordinate;\n\
+#else\n\
+    vec4 windowCoord = vec4(fragmentCoordinateXY, depthOrLogDepth, 1.0);\n\
+    vec4 eyeCoordinate = czm_windowToEyeCoordinates(windowCoord);\n\
+#endif\n\
+    return eyeCoordinate;\n\
+}\n\
+";

package/Source/Shaders/Builtin/Functions/writeDepthClamp.glsl

@@ -0,0 +1,27 @@
+// emulated noperspective
+#if defined(GL_EXT_frag_depth) && !defined(LOG_DEPTH)
+varying float v_WindowZ;
+#endif
+
+/**
+ * Emulates GL_DEPTH_CLAMP. Clamps a fragment to the near and far plane
+ * by writing the fragment's depth. See czm_depthClamp for more details.
+ * <p>
+ * The shader must enable the GL_EXT_frag_depth extension.
+ * </p>
+ *
+ * @name czm_writeDepthClamp
+ * @glslFunction
+ *
+ * @example
+ * gl_FragColor = color;
+ * czm_writeDepthClamp();
+ *
+ * @see czm_depthClamp
+ */
+void czm_writeDepthClamp()
+{
+#if defined(GL_EXT_frag_depth) && !defined(LOG_DEPTH)
+    gl_FragDepthEXT = clamp(v_WindowZ * gl_FragCoord.w, 0.0, 1.0);
+#endif
+}

package/Source/Shaders/Builtin/Functions/writeDepthClamp.js

@@ -0,0 +1,29 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "// emulated noperspective\n\
+#if defined(GL_EXT_frag_depth) && !defined(LOG_DEPTH)\n\
+varying float v_WindowZ;\n\
+#endif\n\
+\n\
+/**\n\
+ * Emulates GL_DEPTH_CLAMP. Clamps a fragment to the near and far plane\n\
+ * by writing the fragment's depth. See czm_depthClamp for more details.\n\
+ * <p>\n\
+ * The shader must enable the GL_EXT_frag_depth extension.\n\
+ * </p>\n\
+ *\n\
+ * @name czm_writeDepthClamp\n\
+ * @glslFunction\n\
+ *\n\
+ * @example\n\
+ * gl_FragColor = color;\n\
+ * czm_writeDepthClamp();\n\
+ *\n\
+ * @see czm_depthClamp\n\
+ */\n\
+void czm_writeDepthClamp()\n\
+{\n\
+#if defined(GL_EXT_frag_depth) && !defined(LOG_DEPTH)\n\
+    gl_FragDepthEXT = clamp(v_WindowZ * gl_FragCoord.w, 0.0, 1.0);\n\
+#endif\n\
+}\n\
+";

package/Source/Shaders/Builtin/Functions/writeLogDepth.glsl

@@ -0,0 +1,82 @@
+#ifdef LOG_DEPTH
+varying float v_depthFromNearPlusOne;
+
+#ifdef POLYGON_OFFSET
+uniform vec2 u_polygonOffset;
+#ifdef GL_OES_standard_derivatives
+#extension GL_OES_standard_derivatives : enable
+#endif
+#endif
+
+#endif
+
+/**
+ * Writes the fragment depth to the logarithmic depth buffer.
+ * <p>
+ * Use this when the vertex shader does not call {@link czm_vertexlogDepth}, for example, when
+ * ray-casting geometry using a full screen quad.
+ * </p>
+ * @name czm_writeLogDepth
+ * @glslFunction
+ *
+ * @param {float} depth The depth coordinate, where 1.0 is on the near plane and
+ *                      depth increases in eye-space units from there
+ *
+ * @example
+ * czm_writeLogDepth((czm_projection * v_positionEyeCoordinates).w + 1.0);
+ */
+void czm_writeLogDepth(float depth)
+{
+#if defined(GL_EXT_frag_depth) && defined(LOG_DEPTH)
+    // Discard the vertex if it's not between the near and far planes.
+    // We allow a bit of epsilon on the near plane comparison because a 1.0
+    // from the vertex shader (indicating the vertex should be _on_ the near
+    // plane) will not necessarily come here as exactly 1.0.
+    if (depth <= 0.9999999 || depth > czm_farDepthFromNearPlusOne) {
+        discard;
+    }
+
+#ifdef POLYGON_OFFSET
+    // Polygon offset: m * factor + r * units
+    float factor = u_polygonOffset[0];
+    float units = u_polygonOffset[1];
+
+// If we can't compute derivatives, just leave out the factor I guess?
+#ifdef GL_OES_standard_derivatives
+    if (factor != 0.0) {
+        // m = sqrt(dZdX^2 + dZdY^2);
+        float x = dFdx(depth);
+        float y = dFdy(depth);
+        float m = sqrt(x * x + y * y);
+
+        // Apply the factor before computing the log depth.
+        depth += m * factor;
+    }
+#endif
+
+#endif
+
+    gl_FragDepthEXT = log2(depth) * czm_oneOverLog2FarDepthFromNearPlusOne;
+
+#ifdef POLYGON_OFFSET
+    // Apply the units after the log depth.
+    gl_FragDepthEXT += czm_epsilon7 * units;
+#endif
+
+#endif
+}
+
+/**
+ * Writes the fragment depth to the logarithmic depth buffer.
+ * <p>
+ * Use this when the vertex shader calls {@link czm_vertexlogDepth}.
+ * </p>
+ *
+ * @name czm_writeLogDepth
+ * @glslFunction
+ */
+void czm_writeLogDepth() {
+#ifdef LOG_DEPTH
+    czm_writeLogDepth(v_depthFromNearPlusOne);
+#endif
+}

package/Source/Shaders/Builtin/Functions/writeLogDepth.js

@@ -0,0 +1,84 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "#ifdef LOG_DEPTH\n\
+varying float v_depthFromNearPlusOne;\n\
+\n\
+#ifdef POLYGON_OFFSET\n\
+uniform vec2 u_polygonOffset;\n\
+#ifdef GL_OES_standard_derivatives\n\
+#extension GL_OES_standard_derivatives : enable\n\
+#endif\n\
+#endif\n\
+\n\
+#endif\n\
+\n\
+/**\n\
+ * Writes the fragment depth to the logarithmic depth buffer.\n\
+ * <p>\n\
+ * Use this when the vertex shader does not call {@link czm_vertexlogDepth}, for example, when\n\
+ * ray-casting geometry using a full screen quad.\n\
+ * </p>\n\
+ * @name czm_writeLogDepth\n\
+ * @glslFunction\n\
+ *\n\
+ * @param {float} depth The depth coordinate, where 1.0 is on the near plane and\n\
+ *                      depth increases in eye-space units from there\n\
+ *\n\
+ * @example\n\
+ * czm_writeLogDepth((czm_projection * v_positionEyeCoordinates).w + 1.0);\n\
+ */\n\
+void czm_writeLogDepth(float depth)\n\
+{\n\
+#if defined(GL_EXT_frag_depth) && defined(LOG_DEPTH)\n\
+    // Discard the vertex if it's not between the near and far planes.\n\
+    // We allow a bit of epsilon on the near plane comparison because a 1.0\n\
+    // from the vertex shader (indicating the vertex should be _on_ the near\n\
+    // plane) will not necessarily come here as exactly 1.0.\n\
+    if (depth <= 0.9999999 || depth > czm_farDepthFromNearPlusOne) {\n\
+        discard;\n\
+    }\n\
+\n\
+#ifdef POLYGON_OFFSET\n\
+    // Polygon offset: m * factor + r * units\n\
+    float factor = u_polygonOffset[0];\n\
+    float units = u_polygonOffset[1];\n\
+\n\
+// If we can't compute derivatives, just leave out the factor I guess?\n\
+#ifdef GL_OES_standard_derivatives\n\
+    if (factor != 0.0) {\n\
+        // m = sqrt(dZdX^2 + dZdY^2);\n\
+        float x = dFdx(depth);\n\
+        float y = dFdy(depth);\n\
+        float m = sqrt(x * x + y * y);\n\
+\n\
+        // Apply the factor before computing the log depth.\n\
+        depth += m * factor;\n\
+    }\n\
+#endif\n\
+\n\
+#endif\n\
+\n\
+    gl_FragDepthEXT = log2(depth) * czm_oneOverLog2FarDepthFromNearPlusOne;\n\
+\n\
+#ifdef POLYGON_OFFSET\n\
+    // Apply the units after the log depth.\n\
+    gl_FragDepthEXT += czm_epsilon7 * units;\n\
+#endif\n\
+\n\
+#endif\n\
+}\n\
+\n\
+/**\n\
+ * Writes the fragment depth to the logarithmic depth buffer.\n\
+ * <p>\n\
+ * Use this when the vertex shader calls {@link czm_vertexlogDepth}.\n\
+ * </p>\n\
+ *\n\
+ * @name czm_writeLogDepth\n\
+ * @glslFunction\n\
+ */\n\
+void czm_writeLogDepth() {\n\
+#ifdef LOG_DEPTH\n\
+    czm_writeLogDepth(v_depthFromNearPlusOne);\n\
+#endif\n\
+}\n\
+";

package/Source/Shaders/Builtin/Functions/writeNonPerspective.glsl

@@ -0,0 +1,32 @@
+/**
+ * Transforms a value for non-perspective interpolation by multiplying
+ * it by w, the value used in the perspective divide. This function is
+ * intended to be called in a vertex shader to compute the value of a
+ * `varying` that should not be subject to perspective interpolation.
+ * For example, screen-space texture coordinates. The fragment shader
+ * must call {@link czm_readNonPerspective} to retrieve the final
+ * non-perspective value.
+ *
+ * @name czm_writeNonPerspective
+ * @glslFunction
+ *
+ * @param {float|vec2|vec3|vec4} value The value to be interpolated without accounting for perspective.
+ * @param {float} w The perspective divide value. Usually this is the computed `gl_Position.w`.
+ * @returns {float|vec2|vec3|vec4} The transformed value, intended to be stored in a `varying` and read in the
+ *          fragment shader with {@link czm_readNonPerspective}.
+ */
+float czm_writeNonPerspective(float value, float w) {
+    return value * w;
+}
+
+vec2 czm_writeNonPerspective(vec2 value, float w) {
+    return value * w;
+}
+
+vec3 czm_writeNonPerspective(vec3 value, float w) {
+    return value * w;
+}
+
+vec4 czm_writeNonPerspective(vec4 value, float w) {
+    return value * w;
+}

package/Source/Shaders/Builtin/Functions/writeNonPerspective.js

@@ -0,0 +1,34 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "/**\n\
+ * Transforms a value for non-perspective interpolation by multiplying\n\
+ * it by w, the value used in the perspective divide. This function is\n\
+ * intended to be called in a vertex shader to compute the value of a\n\
+ * `varying` that should not be subject to perspective interpolation.\n\
+ * For example, screen-space texture coordinates. The fragment shader\n\
+ * must call {@link czm_readNonPerspective} to retrieve the final\n\
+ * non-perspective value.\n\
+ *\n\
+ * @name czm_writeNonPerspective\n\
+ * @glslFunction\n\
+ *\n\
+ * @param {float|vec2|vec3|vec4} value The value to be interpolated without accounting for perspective.\n\
+ * @param {float} w The perspective divide value. Usually this is the computed `gl_Position.w`.\n\
+ * @returns {float|vec2|vec3|vec4} The transformed value, intended to be stored in a `varying` and read in the\n\
+ *          fragment shader with {@link czm_readNonPerspective}.\n\
+ */\n\
+float czm_writeNonPerspective(float value, float w) {\n\
+    return value * w;\n\
+}\n\
+\n\
+vec2 czm_writeNonPerspective(vec2 value, float w) {\n\
+    return value * w;\n\
+}\n\
+\n\
+vec3 czm_writeNonPerspective(vec3 value, float w) {\n\
+    return value * w;\n\
+}\n\
+\n\
+vec4 czm_writeNonPerspective(vec4 value, float w) {\n\
+    return value * w;\n\
+}\n\
+";

package/Source/Shaders/Builtin/Structs/depthRangeStruct.glsl

@@ -0,0 +1,9 @@
+/**
+ * @name czm_depthRangeStruct
+ * @glslStruct
+ */
+struct czm_depthRangeStruct
+{
+    float near;
+    float far;
+};

package/Source/Shaders/Builtin/Structs/depthRangeStruct.js

@@ -0,0 +1,11 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "/**\n\
+ * @name czm_depthRangeStruct\n\
+ * @glslStruct\n\
+ */\n\
+struct czm_depthRangeStruct\n\
+{\n\
+    float near;\n\
+    float far;\n\
+};\n\
+";

package/Source/Shaders/Builtin/Structs/material.glsl

@@ -0,0 +1,22 @@
+/**
+ * Holds material information that can be used for lighting. Returned by all czm_getMaterial functions.
+ *
+ * @name czm_material
+ * @glslStruct
+ *
+ * @property {vec3} diffuse Incoming light that scatters evenly in all directions.
+ * @property {float} specular Intensity of incoming light reflecting in a single direction.
+ * @property {float} shininess The sharpness of the specular reflection.  Higher values create a smaller, more focused specular highlight.
+ * @property {vec3} normal Surface's normal in eye coordinates. It is used for effects such as normal mapping. The default is the surface's unmodified normal.
+ * @property {vec3} emission Light emitted by the material equally in all directions. The default is vec3(0.0), which emits no light.
+ * @property {float} alpha Alpha of this material. 0.0 is completely transparent; 1.0 is completely opaque.
+ */
+struct czm_material
+{
+    vec3 diffuse;
+    float specular;
+    float shininess;
+    vec3 normal;
+    vec3 emission;
+    float alpha;
+};

package/Source/Shaders/Builtin/Structs/material.js

@@ -0,0 +1,24 @@
+//This file is automatically rebuilt by the Cesium build process.
+export default "/**\n\
+ * Holds material information that can be used for lighting. Returned by all czm_getMaterial functions.\n\
+ *\n\
+ * @name czm_material\n\
+ * @glslStruct\n\
+ *\n\
+ * @property {vec3} diffuse Incoming light that scatters evenly in all directions.\n\
+ * @property {float} specular Intensity of incoming light reflecting in a single direction.\n\
+ * @property {float} shininess The sharpness of the specular reflection.  Higher values create a smaller, more focused specular highlight.\n\
+ * @property {vec3} normal Surface's normal in eye coordinates. It is used for effects such as normal mapping. The default is the surface's unmodified normal.\n\
+ * @property {vec3} emission Light emitted by the material equally in all directions. The default is vec3(0.0), which emits no light.\n\
+ * @property {float} alpha Alpha of this material. 0.0 is completely transparent; 1.0 is completely opaque.\n\
+ */\n\
+struct czm_material\n\
+{\n\
+    vec3 diffuse;\n\
+    float specular;\n\
+    float shininess;\n\
+    vec3 normal;\n\
+    vec3 emission;\n\
+    float alpha;\n\
+};\n\
+";

package/Source/Shaders/Builtin/Structs/materialInput.glsl

@@ -0,0 +1,28 @@
+/**
+ * Used as input to every material's czm_getMaterial function.
+ *
+ * @name czm_materialInput
+ * @glslStruct
+ *
+ * @property {float} s 1D texture coordinates.
+ * @property {vec2} st 2D texture coordinates.
+ * @property {vec3} str 3D texture coordinates.
+ * @property {vec3} normalEC Unperturbed surface normal in eye coordinates.
+ * @property {mat3} tangentToEyeMatrix Matrix for converting a tangent space normal to eye space.
+ * @property {vec3} positionToEyeEC Vector from the fragment to the eye in eye coordinates.  The magnitude is the distance in meters from the fragment to the eye.
+ * @property {float} height The height of the terrain in meters above or below the WGS84 ellipsoid.  Only available for globe materials.
+ * @property {float} slope The slope of the terrain in radians.  0 is flat; pi/2 is vertical.  Only available for globe materials.
+ * @property {float} aspect The aspect of the terrain in radians.  0 is East, pi/2 is North, pi is West, 3pi/2 is South.  Only available for globe materials.
+ */
+struct czm_materialInput
+{
+    float s;
+    vec2 st;
+    vec3 str;
+    vec3 normalEC;
+    mat3 tangentToEyeMatrix;
+    vec3 positionToEyeEC;
+    float height;
+    float slope;
+    float aspect;
+};