Add existing to tracked

node_modules/@cesium/engine/Source/Shaders/Voxels/convertLocalToCylinderUv.glsl

@@ -0,0 +1,95 @@
+uniform vec3 u_cylinderLocalToShapeUvScale; // x = radius scale, y = angle scale, z = height scale
+uniform float u_cylinderShapeUvAngleRangeOrigin;
+uniform mat3 u_cylinderEcToRadialTangentUp;
+uniform ivec4 u_cameraTileCoordinates;
+uniform vec3 u_cameraTileUv;
+uniform vec3 u_cameraShapePosition; // (radial distance, angle, height) of camera in shape space
+
+mat3 convertLocalToShapeSpaceDerivative(in vec3 position) {
+    vec3 radial = normalize(vec3(position.xy, 0.0));
+    vec3 z = vec3(0.0, 0.0, 1.0);
+    vec3 east = normalize(vec3(-position.y, position.x, 0.0));
+    return mat3(radial, east / length(position.xy), z);
+}
+
+vec3 scaleShapeUvToShapeSpace(in vec3 shapeUv) {
+    float radius = shapeUv.x / u_cylinderLocalToShapeUvScale.x;
+    float angle = shapeUv.y * czm_twoPi / u_cylinderLocalToShapeUvScale.y;
+    float height = shapeUv.z / u_cylinderLocalToShapeUvScale.z;
+
+    return vec3(radius, angle, height);
+}
+
+/**
+ * Computes the change in polar coordinates given a change in position.
+ * @param {vec2} dPosition The change in position in Cartesian coordinates.
+ * @param {float} cameraRadialDistance The radial distance of the camera from the origin.
+ * @return {vec2} The change in polar coordinates (radial distance, angle).
+ */
+vec2 computePolarChange(in vec2 dPosition, in float cameraRadialDistance) {
+    float dAngle = atan(dPosition.y, cameraRadialDistance + dPosition.x);
+    // Find the direction of the radial axis at the output angle, in Cartesian coordinates
+    vec2 outputRadialAxis = vec2(cos(dAngle), sin(dAngle));
+    float sinHalfAngle = sin(dAngle / 2.0);
+    float versine = 2.0 * sinHalfAngle * sinHalfAngle;
+    float dRadial = dot(dPosition, outputRadialAxis) - cameraRadialDistance * versine;
+    return vec2(dRadial, dAngle);
+}
+
+vec3 convertEcToDeltaShape(in vec3 positionEC) {
+    // 1. Rotate to radial, tangent, and up coordinates
+    vec3 rtu = u_cylinderEcToRadialTangentUp * positionEC;
+    // 2. Compute change in angular and radial coordinates.
+    vec2 dPolar = computePolarChange(rtu.xy, u_cameraShapePosition.x);
+    return vec3(dPolar.xy, rtu.z);
+}
+
+vec3 convertEcToDeltaTile(in vec3 positionEC) {
+    vec3 deltaShape = convertEcToDeltaShape(positionEC);
+    // Convert to tileset coordinates in [0, 1]
+    float dx = u_cylinderLocalToShapeUvScale.x * deltaShape.x;
+    float dy = deltaShape.y / czm_twoPi;
+#if defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE)
+    // Wrap to ensure dy is not crossing through the unoccupied angle range, where
+    // angle to tile coordinate conversions would be more complicated
+    float cameraUvAngle = (u_cameraShapePosition.y + czm_pi) / czm_twoPi;
+    float cameraUvAngleShift = fract(cameraUvAngle - u_cylinderShapeUvAngleRangeOrigin);
+    float rawOutputUvAngle = cameraUvAngleShift + dy;
+    float rotation = floor(rawOutputUvAngle);
+    dy -= rotation;
+#endif
+    dy *= u_cylinderLocalToShapeUvScale.y;
+    float dz = u_cylinderLocalToShapeUvScale.z * deltaShape.z;
+    // Convert to tile coordinate changes
+    return vec3(dx, dy, dz) * float(1 << u_cameraTileCoordinates.w);
+}
+
+TileAndUvCoordinate getTileAndUvCoordinate(in vec3 positionEC) {
+    vec3 deltaTileCoordinate = convertEcToDeltaTile(positionEC);
+    vec3 tileUvSum = u_cameraTileUv + deltaTileCoordinate;
+    ivec3 tileCoordinate = u_cameraTileCoordinates.xyz + ivec3(floor(tileUvSum));
+    int maxTileCoordinate = (1 << u_cameraTileCoordinates.w) - 1;
+    tileCoordinate.x = min(max(0, tileCoordinate.x), maxTileCoordinate);
+    tileCoordinate.z = min(max(0, tileCoordinate.z), maxTileCoordinate);
+#if (!defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE))
+    ivec3 tileCoordinateChange = tileCoordinate - u_cameraTileCoordinates.xyz;
+    if (tileCoordinate.y < 0) {
+        tileCoordinate.y += (maxTileCoordinate + 1);
+    } else if (tileCoordinate.y > maxTileCoordinate) {
+        tileCoordinate.y -= (maxTileCoordinate + 1);
+    }
+#else
+    tileCoordinate.y = min(max(0, tileCoordinate.y), maxTileCoordinate);
+    ivec3 tileCoordinateChange = tileCoordinate - u_cameraTileCoordinates.xyz;
+#endif
+    vec3 tileUv = tileUvSum - vec3(tileCoordinateChange);
+    tileUv.x = clamp(tileUv.x, 0.0, 1.0);
+#if (!defined(CYLINDER_HAS_SHAPE_BOUNDS_ANGLE))
+    // If there is only one tile spanning 2*PI angle, the coordinate wraps around
+    tileUv.y = (u_cameraTileCoordinates.w == 0) ? fract(tileUv.y) : clamp(tileUv.y, 0.0, 1.0);
+#else
+    tileUv.y = clamp(tileUv.y, 0.0, 1.0);
+#endif
+    tileUv.z = clamp(tileUv.z, 0.0, 1.0);
+    return TileAndUvCoordinate(ivec4(tileCoordinate, u_cameraTileCoordinates.w), tileUv);
+}