snappy 3.0.3__cp38-cp38-macosx_11_0_arm64.whl → 3.2__cp38-cp38-macosx_11_0_arm64.whl

snappy/raytracing/shaders/fragment.glsl

@@ -25,7 +25,8 @@ out vec4 out_FragColor;
 //--------------------------------------------
 
 uniform vec2 screenResolution;
-uniform float fov;
+uniform float viewScale;
+uniform bool crosshairs;
 
 uniform int currentTetIndex;
 uniform mat4 currentBoost;
@@ -34,7 +35,7 @@ uniform float currentWeight;
 uniform int maxSteps;
 uniform float maxDist;
 uniform int subpixelCount;
-uniform float edgeThickness;
+uniform float edgeThicknessParam;
 uniform float contrast;
 
 const int perspectiveTypeMaterial   = 0;
@@ -53,9 +54,13 @@ uniform bool showElevation = false;
 // The string ##NAME## is replaced by the code in __init__.py
 // by looking up its value in the dictionary constants_dict.
 
-uniform int otherTetNums[4 * ##num_tets##]; 
-uniform int otherFaceNums[4 * ##num_tets##]; 
-uniform float weights[4 * ##num_tets##]; 
+layout (std140) uniform TetrahedraCombinatorics
+{
+    int otherTetNums[4 * ##num_tets##];
+    int otherFaceNums[4 * ##num_tets##];
+};
+
+uniform float weights[4 * ##num_tets##];
 
 layout (std140) uniform TetrahedraBasics
 {
@@ -64,18 +69,20 @@ layout (std140) uniform TetrahedraBasics
     mat4 SO13tsfms[4 * ##num_tets##];
 };
 
-uniform float edgeTubeRadiusParam;
-
-// +1 or -1 depending on orientation of tetrahedron.
-uniform int orientations[##num_tets##];
+layout (std140) uniform Colors
+{
+    int face_color_indices[4 * ##num_tets##];
+    int edge_color_indices[6 * ##num_tets##];
+    int vertex_color_indices[4 * ##num_tets##];
+};
 
-uniform int face_color_indices[4 * ##num_tets##];
-uniform int edge_color_indices[6 * ##num_tets##];
-uniform int vertex_color_indices[4 * ##num_tets##];
+uniform bool desaturate_edges = false;
 
-uniform float gradientThreshholds[5];
+uniform float gradientThresholds[5];
 uniform vec3 gradientColours[5];
 
+uniform float edgeTubeRadiusParam;
+
 uniform float lightBias;
 uniform float lightFalloff;
 uniform float brightness;
@@ -83,6 +90,7 @@ const vec4 lightSourcePosition = vec4(1.0, 0.0, 0.7, 0.0);
 
 uniform bool isNonGeometric;
 uniform sampler2D nonGeometricTexture;
+uniform sampler2D eyeTexture;
 
 const int num_tets = ##num_tets##;
 const int num_edges = ##num_edges##;
@@ -109,7 +117,7 @@ uniform float vertexSphereRadiusParam;
 // For an incomplete cusp, the Margulis tube is a cylinder about
 // the geodesic the triangulation spins about. In other words,
 // it is the cylinder fixed by the peripheral group of that cusp.
-// We encode it by its two end points and cosh(radius/2)^2/2.
+// We encode it by its two end points and cosh(radius)^2/2.
 layout (std140) uniform MargulisTubes
 {
     vec4 margulisTubeTails[4 * ##num_tets##];
@@ -117,14 +125,71 @@ layout (std140) uniform MargulisTubes
 };
 uniform float margulisTubeRadiusParams[4 * ##num_tets##];
 
+#if defined(num_geodesic_segments) && num_geodesic_segments > 0
+layout (std140) uniform geodesics
+{
+    vec4 geodesicTails[num_geodesic_segments];
+    vec4 geodesicHeads[num_geodesic_segments];
+    int geodesicIndex[num_geodesic_segments];
+    float geodesicTubeRadiusParam[num_geodesic_segments];
+    int geodesicOffsets[##num_tets## + 1];
+};
+#endif
+
+#if !defined(num_eyeballs)
+#define num_eyeballs 0
+#endif
+
+#if num_eyeballs > 0
+layout (std140) uniform eyeballs
+{
+    vec4 eyeballPositions[num_eyeballs];
+    mat4 eyeballInvEmbeddings[num_eyeballs];
+    mat4 eyeballEmbeddings[num_eyeballs];
+    int eyeballOffsets[##num_tets## + 1];
+};
+uniform float eyeballRadius;
+
+#if eyeball_type == 2
+float eyeballRadiusParam = cosh(eyeballRadius) * cosh(eyeballRadius);
+#else
+float space_ship_width = 0.4;
+float space_ship_fold_width = 0.13;
+float space_ship_fold_height = 0.3;
+
+vec4 space_ship_top_plane = vec4(0.0, 0.0, -1.0, 0.0);
+vec4 space_ship_edges[2] = vec4[2](
+    vec4(0.0,  1.0 / space_ship_width, 0.0, 1.0),
+    vec4(0.0, -1.0 / space_ship_width, 0.0, 1.0));
+vec4 space_ship_folds[2] = vec4[2](
+    vec4(0.0,  1.0 / space_ship_fold_width, 1.0 / space_ship_fold_height, 1.0),
+    vec4(0.0, -1.0 / space_ship_fold_width, 1.0 / space_ship_fold_height, 1.0));
+float b = length(vec2(space_ship_fold_height, 1.0));
+vec4 space_ship_back_plane = vec4(sinh(eyeballRadius), 0.0, 0.0, -b * cosh(eyeballRadius));
+#endif
+
+#endif
+
 uniform float horosphereScales[4 * ##num_tets##];
 
-// Heights of the Euclidean triangle obtained when intersecting
-// horosphere with tetrahedron.
-// There are four horospheres about the four edges of the tetrahedron,
-// giving four triangles but they are all similar, so storing only
-// one per tet.
-uniform vec3 horotriangleHeights[##num_tets##];
+#if defined(num_additional_horospheres) && num_additional_horospheres > 0
+layout (std140) uniform additionalHorospheres
+{
+    vec4 horosphereVec[num_additional_horospheres];
+    int horosphereCuspIndex[num_additional_horospheres];
+    int horosphereOffsets[##num_tets## + 1];
+};
+
+#endif
+
+#if defined(has_edge_midpoints)
+layout (std140) uniform edgeMidpoints
+{
+    vec4 edgeMidpointVec[6 * ##num_tets##];
+};
+
+uniform float edgeMidpointRadiusParam;
+#endif
 
 // cosh(r)^2 where r is the radius of the sphere
 // about the center of the tetrahedron.
@@ -139,7 +204,7 @@ layout (std140) uniform TetCuspMatrices
 };
 
 uniform vec2 logAdjustments[4 * ##num_tets##];
-uniform mat2 matLogs[4 * ##num_tets##];
+uniform mat2 toStandardTorusMatrices[4 * ##num_tets##];
 
 const float peripheralCurveThickness = 0.015;
 
@@ -212,7 +277,7 @@ triangleBdryParam(vec4 samplePoint, int tetNum, int exit_face){
           float new_p = geodesicParameterPlanes(samplePoint, exit_dual_point, planes[index]);
           if(new_p < smallest_p){
             smallest_p = new_p;
-          }   
+          }
       }
   }
   return smallest_p;
@@ -222,17 +287,23 @@ triangleBdryParam(vec4 samplePoint, int tetNum, int exit_face){
 
 // Kind of object a ray hit.
 
-const int object_type_nothing             = 0;
-const int object_type_face                = 1;
-const int object_type_edge_cylinder_enter = 2;
-const int object_type_edge_cylinder_exit  = 3;
-const int object_type_horosphere          = 4;
-const int object_type_edge_fan            = 5;
-const int object_type_insphere            = 6;
-const int object_type_vertex_sphere       = 7;
-const int object_type_margulis_tube       = 8;
-const int object_type_elevation_enter     = 9;
-const int object_type_elevation_exit      = 10;
+const int object_type_nothing               =  0;
+const int object_type_face                  =  1;
+const int object_type_edge_cylinder_enter   =  2;
+const int object_type_edge_cylinder_exit    =  3;
+const int object_type_horosphere_enter      =  4;
+const int object_type_horosphere_exit       =  5;
+const int object_type_edge_fan              =  6;
+const int object_type_insphere              =  7;
+const int object_type_vertex_sphere         =  8;
+const int object_type_margulis_tube_enter   =  9;
+const int object_type_margulis_tube_exit    = 10;
+const int object_type_elevation_enter       = 11;
+const int object_type_elevation_exit        = 12;
+const int object_type_geodesic_tube         = 13;
+const int object_type_additional_horosphere = 14;
+const int object_type_eyeball               = 15;
+const int object_type_edge_midpoint         = 16;
 
 // A ray consists of a point in the hyperbolid model and a
 // unit tangent vector dir orthogonal to the point with respect
@@ -259,8 +330,19 @@ struct RayHit
     // Index of object (within the tetrahedron), e.g.,
     // 0-3 for horospheres, 0-5 for edges.
     int object_index;
+
+    int object_subindex;
 };
 
+bool traceInsideVertexNeighborhood()
+{
+#if num_eyeballs > 0
+    return eyeballOffsets[##num_tets##] > 0;
+#else
+    return false;
+#endif
+}
+
 // We distinguish between:
 // - colored ray hits: the geometry is lit, e.g., the cylinder
 //   about an edge reacts to light)
@@ -272,16 +354,15 @@ struct RayHit
 //
 bool isColored(RayHit ray_hit)
 {
-    return
-        ray_hit.object_type == object_type_vertex_sphere ||
-        ray_hit.object_type == object_type_insphere ||
-        ray_hit.object_type == object_type_horosphere ||
-        ray_hit.object_type == object_type_edge_cylinder_enter ||
-        ray_hit.object_type == object_type_edge_cylinder_exit ||
-        ray_hit.object_type == object_type_margulis_tube ||
-        ray_hit.object_type == object_type_edge_fan ||
-        ray_hit.object_type == object_type_elevation_enter ||
-        ray_hit.object_type == object_type_elevation_exit;
+    return !(
+        ray_hit.object_type == object_type_nothing ||
+        ray_hit.object_type == object_type_face);
+}
+
+vec4
+pointAdvancedByParam(Ray ray, float p)
+{
+    return R13Normalise(ray.point + p * ray.dir );
 }
 
 // Advances ray by distance atanh(p).
@@ -291,7 +372,7 @@ bool isColored(RayHit ray_hit)
 void
 advanceRayByDistParam(inout Ray ray, float p)
 {
-    ray.point = R13Normalise(ray.point + p * ray.dir );
+    ray.point = pointAdvancedByParam(ray, p);
     ray.dir = makeUnitTangentVector(ray.dir, ray.point);
 }
 
@@ -331,7 +412,7 @@ realRootsOfQuadratic(float a, float b, float c,
 
 // Intersection with plane.
 // The plane is given by all points such that the inner product
-// of the point and the planeEqn is zero. 
+// of the point and the planeEqn is zero.
 float
 distParamForPlaneIntersection(Ray ray,
                               vec4 planeEqn)
@@ -351,11 +432,11 @@ distParamForPlaneIntersection(Ray ray,
 // The last parameter is the cosh(radius)^2.
 vec2
 distParamsForSphereIntersection(Ray ray,
-                               vec4 center, float sphereRadiusParam)
+                                vec4 center, float sphereRadiusParam)
 {
     float startDot = R13Dot(center, ray.point);
     float dirDot   = R13Dot(center, ray.dir);
-    
+
     return realRootsOfQuadratic(
         dirDot * dirDot + sphereRadiusParam,
         2.0 * dirDot * startDot,
@@ -375,17 +456,44 @@ distParamsForHorosphereIntersection(Ray ray,
 
 // Intersection with cylinder about the geodesic with the two given
 // (light-like) endpoints.
-// tubeRadiusParam is cosh(radius/2)^2/2.
+// tubeRadiusParam is cosh(radius)^2/2.
 // This function can detect intersections of the ray that happen
 // some distance before the start point of the ray. To use this feature,
 // set minDistParam to a negative value, namely to tanh(-distance),
 // where distance is how far back we want to track the ray.
 vec2
 distParamsForTubeIntersection(Ray ray,
-                             vec4[2] endpoints,
-                             float tubeRadiusParam,
-                             float minDistParam)
+                              vec4[2] endpoints,
+                              float tubeRadiusParam,
+                              float minDistParam)
 {
+    // The points p (with R13Dot(p,p) = -1) on a tube about a
+    // geodesic are given by
+    //
+    //     -tubeRadiusParam * R13Dot(endpoints[0], endpoints[1])
+    //           = R13Dot(endpoints[0],p) * R13Dot(endpoints[1],p)
+    //
+    // To see this, note that the isometries of the tube about
+    // the geodesic act on the light-like endpoints by multiplying
+    // them by s and 1/s, respectively, where s > 0. It is easy
+    // to check that the equation is invariant under this action.
+    //
+    // To compute the tubeRadiusParam in terms of the tube radius,
+    // place the endpoints at (1,-1,0,0) and (1,1,0,0) and p at
+    // (cosh(radius),0,sinh(radius),0). We obtain
+    //
+    //      tubeRadiusParam = cosh(radius)^2/2
+    //
+    // The ray is parameterized by
+    //
+    //      p = p0 / sqrt(-R13Dot(p0, p0))
+    //
+    // where
+    //     p0 = ray.point + t * ray.dir.
+    //
+    // Putting p into the above equation and multiplying by
+    // -R13Dot(p0, p0), we obtain a quadratic equation we can solve for.
+
     float start0Dot = R13Dot(endpoints[0], ray.point);
     float dir0Dot   = R13Dot(endpoints[0], ray.dir);
     float start1Dot = R13Dot(endpoints[1], ray.point);
@@ -470,6 +578,17 @@ horosphereEqn(int index)
 {
     return horosphereScales[index] * R13Vertices[index];
 }
+
+#if defined(num_geodesic_segments) && num_geodesic_segments > 0
+// The two endpoints of a geodesic
+vec4[2]
+endpointsForGeodesic(int index)
+{
+    return vec4[](geodesicTails[index],
+                  geodesicHeads[index]);
+}
+#endif
+
 #endif
 
 vec4
@@ -485,19 +604,76 @@ normalForRayHit(RayHit ray_hit)
         return normalForSphere(ray_hit.ray.point, vec4(1,0,0,0));
     }
 
-    if(ray_hit.object_type == object_type_horosphere) {
+    if(ray_hit.object_type == object_type_horosphere_enter) {
         int index = 4 * ray_hit.tet_num + ray_hit.object_index;
         return horosphereEqn(index) - ray_hit.ray.point;
     }
 
-    if(ray_hit.object_type == object_type_margulis_tube) {
+    if(ray_hit.object_type == object_type_horosphere_exit) {
+        int index = 4 * ray_hit.tet_num + ray_hit.object_index;
+        return ray_hit.ray.point - horosphereEqn(index);
+    }
+
+    if(ray_hit.object_type == object_type_margulis_tube_enter) {
         int index = 4 * ray_hit.tet_num + ray_hit.object_index;
         return normalForTube(
             ray_hit.ray.point,
             endpointsForMargulisTube(index));
     }
-#endif    
-    
+
+    if(ray_hit.object_type == object_type_margulis_tube_exit) {
+        int index = 4 * ray_hit.tet_num + ray_hit.object_index;
+        return - normalForTube(
+            ray_hit.ray.point,
+            endpointsForMargulisTube(index));
+    }
+
+#if defined(num_geodesic_segments) && num_geodesic_segments > 0
+    if (ray_hit.object_type == object_type_geodesic_tube) {
+        return normalForTube(
+            ray_hit.ray.point,
+            endpointsForGeodesic(ray_hit.object_index));
+    }
+#endif
+
+#if defined(num_additional_horospheres) && num_additional_horospheres > 0
+    if (ray_hit.object_type == object_type_additional_horosphere) {
+        return horosphereVec[ray_hit.object_index] - ray_hit.ray.point;
+    }
+#endif
+
+#if num_eyeballs > 0
+    if (ray_hit.object_type == object_type_eyeball) {
+#if eyeball_type == 2
+        return normalForSphere(
+            ray_hit.ray.point, eyeballPositions[ray_hit.object_index]);
+#else       
+        vec4 local_normal;
+        if (ray_hit.object_subindex == 0) {
+            local_normal = space_ship_top_plane;
+        } else {
+            local_normal = R13Normalise(space_ship_folds[ray_hit.object_subindex - 1]);
+        }
+        vec4 normal = local_normal * eyeballEmbeddings[ray_hit.object_index];
+
+        if (R13Dot(ray_hit.ray.dir, normal) > 0) {
+            return normal;
+        } else {
+            return -normal;
+        }
+#endif
+    }
+#endif
+
+#if defined(has_edge_midpoints)
+    if (ray_hit.object_type == object_type_edge_midpoint) {
+	int index = 6 * ray_hit.tet_num + ray_hit.object_index;
+	return normalForSphere(ray_hit.ray.point, edgeMidpointVec[index]);
+    }
+#endif
+
+#endif
+
     if(ray_hit.object_type == object_type_edge_fan ||
        ray_hit.object_type == object_type_elevation_enter ||
        ray_hit.object_type == object_type_elevation_exit) {
@@ -531,8 +707,8 @@ hyperboloidToUpperHalfspace(vec4 h)
     vec3 poincare = klein / (1.0 + sqrt(1.0 - dot(klein, klein)));
     vec3 denom_helper = vec3(poincare.x - 1.0, poincare.yz);
     float denom = dot(denom_helper, denom_helper);
-    
-    return vec3(2.0 * poincare.yz, 1.0 - dot(poincare, poincare)) / denom;   
+
+    return vec3(2.0 * poincare.yz, 1.0 - dot(poincare, poincare)) / denom;
 }
 
 #if !##finiteTrig##
@@ -557,15 +733,35 @@ vec2
 MLCoordinatesForRayHit(RayHit rayHit)
 {
     int index = 4 * rayHit.tet_num + rayHit.object_index;
-    
+
     vec3 pointUpperHalfspace = preferredUpperHalfspaceCoordinates(rayHit);
     vec2 z = pointUpperHalfspace.xy;
 
-    if (rayHit.object_type == object_type_margulis_tube) {
+    if (rayHit.object_type == object_type_margulis_tube_enter ||
+        rayHit.object_type == object_type_margulis_tube_exit) {
         z = complexLog(z) + logAdjustments[index];
     }
 
-    return z * matLogs[index];
+    return z * toStandardTorusMatrices[index];
+}
+
+int
+peripheralCurveForMLCoordinates(vec2 ml_coordinates)
+{
+    // Map R^2->torus
+    vec2 f = fract(ml_coordinates);
+
+    if ( f.y <       peripheralCurveThickness ||
+         f.y > 1.0 - peripheralCurveThickness) {
+        return 2;
+    }
+
+    if ( f.x <       peripheralCurveThickness ||
+         f.x > 1.0 - peripheralCurveThickness) {
+        return 1;
+    }
+
+    return 0;
 }
 #endif
 
@@ -577,7 +773,7 @@ mat4
 parabolicSO13(vec2 z)
 {
     float t = dot(z, z) / 2.0;
-    
+
     return mat4( 1.0 + t,     - t,     z.x,     z.y,
                        t, 1.0 - t,     z.x,     z.y,
                      z.x,    -z.x,     1.0,     0.0,
@@ -601,18 +797,75 @@ ray_trace_through_hyperboloid_tet(inout RayHit ray_hit)
 {
     int entry_object_type = ray_hit.object_type;
     int entry_object_index = ray_hit.object_index;
- 
+
     ///Given shape of a tet and a ray, find where the ray exits and through which face
     float smallest_p = 100000000.0;
 
+    float horosphere_exit_param = -unreachableDistParam;
+
+#if !##finiteTrig##
+    for (int vertex = 0; vertex < 4; vertex++) {
+        int index = 4 * ray_hit.tet_num + vertex;
+        if ( horosphereScales[index] != 0.0 ||
+             margulisTubeRadiusParams[index] > 0.50001) {
+
+            vec2 params;
+            if (horosphereScales[index] != 0.0) {
+                params = distParamsForHorosphereIntersection(
+                    ray_hit.ray,
+                    horosphereEqn(index));
+            } else {
+                params = distParamsForTubeIntersection(
+                    ray_hit.ray,
+                    endpointsForMargulisTube(index),
+                    margulisTubeRadiusParams[index],
+                    0.0);
+            }
+
+            if (params.x < smallest_p) {
+                smallest_p = params.x;
+                if (horosphereScales[index] != 0.0) {
+                    ray_hit.object_type = object_type_horosphere_enter;
+                } else {
+                    ray_hit.object_type = object_type_margulis_tube_enter;
+                }
+                ray_hit.object_index = vertex;
+            }
+
+            if (traceInsideVertexNeighborhood()) {
+                if (params.y < smallest_p) {
+                    horosphere_exit_param = params.y;
+                    ray_hit.distWhenLeavingCusp = ray_hit.dist + atanh(params.y);
+
+                    RayHit new_hit = ray_hit;
+                    new_hit.object_index = vertex;
+                    advanceRayByDistParam(new_hit.ray, params.y);
+
+                    if (peripheralCurveForMLCoordinates(
+                            MLCoordinatesForRayHit(new_hit)) > 0) {
+                        smallest_p = params.y;
+
+                        if (horosphereScales[index] != 0.0) {
+                            ray_hit.object_type = object_type_horosphere_exit;
+                        } else {
+                            ray_hit.object_type = object_type_margulis_tube_exit;
+                        }
+                        ray_hit.object_index = vertex;
+                    }
+                }
+            }
+        }
+    }
+#endif
+
     for(int face = 0; face < 4; face++) {
         if (entry_object_type != object_type_face || entry_object_index != face) {
             // find p when we hit that face
             int index = 4 * ray_hit.tet_num + face;
-            if(R13Dot(ray_hit.ray.dir, planes[index]) > 0.0){ 
+            if(R13Dot(ray_hit.ray.dir, planes[index]) > 0.0){
                 float p = distParamForPlaneIntersection(ray_hit.ray, planes[index]);
                 // if ((-10000.0 <= p) && (p < smallest_p)) {
-                if (p < smallest_p) {  
+                if (p < smallest_p) {
                     /// negative values are ok if we have to go backwards a little to get through the face we are a little the wrong side of
                     /// Although this can apparently get caught in infinite loops in an edge
 
@@ -652,7 +905,8 @@ ray_trace_through_hyperboloid_tet(inout RayHit ray_hit)
                 ray_hit.ray,
                 vec4(1,0,0,0),
                 r).x;
-            if (p < smallest_p) {
+            if (p < smallest_p && (!traceInsideVertexNeighborhood() ||
+                                   p > horosphere_exit_param)) {
                 smallest_p = p;
                 ray_hit.object_type = object_type_insphere;
                 ray_hit.object_index = 0;
@@ -660,42 +914,133 @@ ray_trace_through_hyperboloid_tet(inout RayHit ray_hit)
         }
     }
 
-    for (int vertex = 0; vertex < 4; vertex++) {
-        int index = 4 * ray_hit.tet_num + vertex;
-        if (horosphereScales[index] != 0.0) {
-            vec2 params = distParamsForHorosphereIntersection(ray_hit.ray,
-                                                              horosphereEqn(index));
-            if (params.x < smallest_p) {
-                smallest_p = params.x;
-                ray_hit.object_type = object_type_horosphere;
-                ray_hit.object_index = vertex;
-            }
+#if defined(has_edge_midpoints)
+    {
+	for (int edge = 0; edge < 6; edge++) {
+	    int index = 6 * ray_hit.tet_num + edge;
+	    float p = distParamsForSphereIntersection(
+		ray_hit.ray,
+		edgeMidpointVec[index],
+		edgeMidpointRadiusParam).x;
+	    if (p < smallest_p) {
+		smallest_p = p;
+		ray_hit.object_type = object_type_edge_midpoint;
+		ray_hit.object_index = edge;
+	    }
+	}
+    }
+#endif
+
+#if defined(num_geodesic_segments) && num_geodesic_segments > 0
+    for (int index = geodesicOffsets[ray_hit.tet_num];
+         index < geodesicOffsets[ray_hit.tet_num + 1];
+         index++) {
+
+        vec2 params = distParamsForTubeIntersection(
+            ray_hit.ray,
+            endpointsForGeodesic(index),
+            geodesicTubeRadiusParam[index],
+            0.0);
+
+        if (params.x < smallest_p && (!traceInsideVertexNeighborhood() ||
+                                      params.x > horosphere_exit_param)) {
+            smallest_p = params.x;
+            ray_hit.object_type = object_type_geodesic_tube;
+            ray_hit.object_index = index;
         }
+    }
+#endif
 
-        if (margulisTubeRadiusParams[index] > 0.50001) {
-            vec2 params = distParamsForTubeIntersection(
-                ray_hit.ray,
-                endpointsForMargulisTube(index),
-                margulisTubeRadiusParams[index],
-                0.0);
+#if defined(num_additional_horospheres) && num_additional_horospheres > 0
+    for (int index = horosphereOffsets[ray_hit.tet_num];
+         index < horosphereOffsets[ray_hit.tet_num + 1];
+         index++) {
 
-            if (params.x < smallest_p) {
-                smallest_p = params.x;
-                ray_hit.object_type = object_type_margulis_tube;
-                ray_hit.object_index = vertex;
+        vec2 params = distParamsForHorosphereIntersection(
+            ray_hit.ray,
+            horosphereVec[index]);
+
+        if (params.x < smallest_p) {
+            smallest_p = params.x;
+            ray_hit.object_type = object_type_additional_horosphere;
+            ray_hit.object_index = index;
+        }
+    }
+#endif
+
+#if num_eyeballs > 0
+    for (int index = eyeballOffsets[ray_hit.tet_num];
+         index < eyeballOffsets[ray_hit.tet_num + 1];
+         index++) {
+
+#if eyeball_type == 2
+        vec2 params = distParamsForSphereIntersection(
+            ray_hit.ray,
+            eyeballPositions[index],
+            eyeballRadiusParam);
+
+        if (params.x < smallest_p) {
+            smallest_p = params.x;
+            ray_hit.object_type = object_type_eyeball;
+            ray_hit.object_index = index;
+        }
+#else
+        Ray local_ray;
+        local_ray.point = ray_hit.ray.point * eyeballInvEmbeddings[index];
+        local_ray.dir = ray_hit.ray.dir * eyeballInvEmbeddings[index];
+
+        {
+            float param = distParamForPlaneIntersection(local_ray, vec4(0.0, 0.0, 1.0, 0.0));
+
+            if (param > 0 && param < smallest_p) {
+                if (ray_hit.dist + atanh(param) > 0.001) {
+                    vec4 hit_point = pointAdvancedByParam(local_ray, param);
+                    if ((dot(hit_point, space_ship_folds[0]) < 0.0 ||
+                         dot(hit_point, space_ship_folds[1]) < 0.0) &&
+                        dot(hit_point, space_ship_back_plane) > 0.0 &&
+                        dot(hit_point, space_ship_edges[0]) > 0.0 &&
+                        dot(hit_point, space_ship_edges[1]) > 0.0) {
+                        smallest_p = param;
+                        ray_hit.object_type = object_type_eyeball;
+                        ray_hit.object_index = index;
+                        ray_hit.object_subindex = 0;
+                    }
+                }
             }
         }
+        
+        for (int s = 0; s < 2; s++) {
+            float param = distParamForPlaneIntersection(local_ray, space_ship_folds[s]);
+            
+            if (param > 0 && param < smallest_p) {
+                if (ray_hit.dist + atanh(param) > 0.001) {
+                    vec4 hit_point = pointAdvancedByParam(local_ray, param);
+                    
+                    if (dot(hit_point, space_ship_back_plane) > 0.0 &&
+                        dot(hit_point, space_ship_top_plane) > 0.0 &&
+                        dot(hit_point, space_ship_folds[1-s]) > 0.0) {
+                        
+                        smallest_p = param;
+                        ray_hit.object_type = object_type_eyeball;
+                        ray_hit.object_index = index;
+                        ray_hit.object_subindex = 1 + s;
+                    }
+                }
+            }
+        }
+#endif
     }
+#endif
 
 #endif
 
-    if (edgeTubeRadiusParam > 0.50001) {
+    if (edgeTubeRadiusParam > 0.500001) {
 
 #if ##finiteTrig##
         float backDistParam = 0.0;
 #else
         float backDistParam = tanh(ray_hit.distWhenLeavingCusp-ray_hit.dist);
-#endif    
+#endif
 
         for (int edge = 0; edge < 6; edge++) {
 
@@ -705,11 +1050,14 @@ ray_trace_through_hyperboloid_tet(inout RayHit ray_hit)
                 edgeTubeRadiusParam,
                 backDistParam);
 
-            if (params.x < smallest_p) {
+            if (params.x < smallest_p && (!traceInsideVertexNeighborhood() ||
+                                          params.x > horosphere_exit_param)) {
                 smallest_p = params.x;
                 ray_hit.object_type = object_type_edge_cylinder_enter;
                 ray_hit.object_index = edge;
-            } else if (params.y < smallest_p) {
+            }
+            if (params.y < smallest_p && (!traceInsideVertexNeighborhood() ||
+                                          params.y > horosphere_exit_param)) {
                 smallest_p = params.y;
                 ray_hit.object_type = object_type_edge_cylinder_exit;
                 ray_hit.object_index = edge;
@@ -720,10 +1068,13 @@ ray_trace_through_hyperboloid_tet(inout RayHit ray_hit)
     ray_hit.dist += atanh(smallest_p);
     advanceRayByDistParam(ray_hit.ray, smallest_p);
 
-    if(edgeThickness > 0.00001) {
+    if(edgeThicknessParam > 0.00001) {
         if (ray_hit.object_type == object_type_face) {
-            if(triangleBdryParam(ray_hit.ray.point, ray_hit.tet_num, ray_hit.object_index) < edgeThickness) {
-                ray_hit.object_type = object_type_edge_fan;
+            if (!traceInsideVertexNeighborhood() ||
+                smallest_p > horosphere_exit_param) {
+                if(triangleBdryParam(ray_hit.ray.point, ray_hit.tet_num, ray_hit.object_index) < edgeThicknessParam) {
+                    ray_hit.object_type = object_type_edge_fan;
+                }
             }
         }
     }
@@ -765,7 +1116,7 @@ ray_trace(inout RayHit ray_hit) {
         // positive values so we get correct behaviour by comparing without the sinh^2. 
         int index = 4 * ray_hit.tet_num + ray_hit.object_index;
 
-        float new_weight = ray_hit.weight + weights[ index ];        
+        float new_weight = ray_hit.weight + weights[ index ];
 
         if (showElevation) {
             int elevation_object_type =
@@ -784,7 +1135,7 @@ ray_trace(inout RayHit ray_hit) {
 
         ray_hit.light_source = ray_hit.light_source * tsfm;
         ray_hit.ray.point = ray_hit.ray.point * tsfm;
-        ray_hit.ray.dir = R13Normalise( ray_hit.ray.dir * tsfm ); 
+        ray_hit.ray.dir = R13Normalise( ray_hit.ray.dir * tsfm );
         ray_hit.tet_num = otherTetNums[ index ];
     }
 }
@@ -793,20 +1144,20 @@ ray_trace(inout RayHit ray_hit) {
 
 /// --- Colour gradient code --- ///
 
-int find_band(float t, float threshholds[5]){
+int find_band(float t, float thresholds[5]){
     for(int j = 1; j < 4; j++) {
-        if(t < threshholds[j]) {
+        if(t < thresholds[j]) {
             return j;
         }
     }
     return 4;
 }
 
-vec3 general_gradient(float t, float threshholds[5], vec3 colours[5]){
-    int i = find_band(t, threshholds);
+vec3 general_gradient(float t, float thresholds[5], vec3 colours[5]){
+    int i = find_band(t, thresholds);
     return mix(colours[i-1],
                colours[i],
-               (t - threshholds[i-1])/(threshholds[i] - threshholds[i-1]));
+               (t - thresholds[i-1])/(thresholds[i] - thresholds[i-1]));
 }
 
 // Given the (average) value for a ray hit, apply gradient to get
@@ -820,7 +1171,7 @@ vec3 colorForValue(float value)
     value = contrast * value;
     value = 0.5 + 0.5 * value/ (abs(value) + 1.0);  //faster than atan, similar
 
-    return general_gradient(value, gradientThreshholds, gradientColours);
+    return general_gradient(value, gradientThresholds, gradientColours);
 }
 
 struct MaterialParams
@@ -849,11 +1200,13 @@ material_params(RayHit ray_hit)
 
         result.diffuse = hsv2rgb(vec3(float(color_index)/float(num_cusps), 0.25, 1.0));
         result.ambient = 0.5 * result.diffuse;
-    }        
+    }
 #else
-    if (ray_hit.object_type == object_type_horosphere ||
-        ray_hit.object_type == object_type_margulis_tube) {
-        
+    if (ray_hit.object_type == object_type_horosphere_enter ||
+        ray_hit.object_type == object_type_horosphere_exit ||
+        ray_hit.object_type == object_type_margulis_tube_enter ||
+        ray_hit.object_type == object_type_margulis_tube_exit) {
+
         int index = 4 * ray_hit.tet_num + ray_hit.object_index;
         int color_index = vertex_color_indices[index];
 
@@ -867,15 +1220,15 @@ material_params(RayHit ray_hit)
 #endif
         result.ambient = 0.5 * result.diffuse;
 
-        vec2 coords = fract(MLCoordinatesForRayHit(ray_hit));
-        
-        if (coords.x <       peripheralCurveThickness ||
-            coords.x > 1.0 - peripheralCurveThickness) {
+        int peripheralCurve =
+            peripheralCurveForMLCoordinates(
+                MLCoordinatesForRayHit(ray_hit));
+
+        if (peripheralCurve == 1) {
             result.diffuse = longitudeColor;
             result.ambient = result.diffuse;
         }
-        if (coords.y <       peripheralCurveThickness ||
-            coords.y > 1.0 - peripheralCurveThickness) {
+        if (peripheralCurve == 2) {
             result.diffuse = meridianColor;
             result.ambient = result.diffuse;
         }
@@ -901,11 +1254,14 @@ material_params(RayHit ray_hit)
     if (ray_hit.object_type == object_type_edge_cylinder_enter) {
         int index = 6 * ray_hit.tet_num + ray_hit.object_index;
         int color_index = edge_color_indices[index];
-        
+
         //using num_tets = num_edges
 
 #if COLOR_SCHEME == 1
-        result.diffuse = hsv2rgb(vec3(float(color_index)/float(num_edges), 1.0, 1.0));
+        result.diffuse = hsv2rgb(
+            vec3(float(color_index)/float(num_edges),
+                 desaturate_edges ? 0.24 : 1.0,
+                 1.0));
 #else
         result.diffuse =
             vec3(0.5, 0.5, 0.5)
@@ -919,7 +1275,7 @@ material_params(RayHit ray_hit)
     if (ray_hit.object_type == object_type_edge_cylinder_exit) {
         int index = 6 * ray_hit.tet_num + ray_hit.object_index;
         int color_index = edge_color_indices[index];
-        
+
         //using num_tets = num_edges
         result.diffuse = 0.3 * hsv2rgb(vec3(float(color_index)/float(num_tets), 1.0, 1.0));
         result.ambient = 0.5 * result.diffuse;
@@ -935,6 +1291,67 @@ material_params(RayHit ray_hit)
         result.ambient = 0.5 * result.diffuse;
     }
 
+#if defined(num_geodesic_segments) && num_geodesic_segments > 0
+    if (ray_hit.object_type == object_type_geodesic_tube) {
+        int index = geodesicIndex[ray_hit.object_index];
+
+        // The user wants to switch geodesics off and on while
+        // their colors stay stable.
+        //
+        // Thus, we cannot divide the color circle equally.
+        //
+        // Instead, we multiply the index by the golden angle
+        //          pi * (3 - sqrt(5)) radians
+        // so that no geodesics hit the same color.
+        //
+        // For hsv2rgb, we need to divide by 2 * pi:
+        //
+        float goldenAngleBy2Pi = 0.3819660112501051;
+
+        result.diffuse = hsv2rgb(vec3(float(index) * goldenAngleBy2Pi + 0.1, 1.0, 1.0));
+
+        result.ambient = 0.5 * result.diffuse;
+    }
+#endif
+
+#if defined(num_additional_horospheres) && num_additional_horospheres > 0
+    if (ray_hit.object_type == object_type_additional_horosphere) {
+        int index = horosphereCuspIndex[ray_hit.object_index];
+
+        // Similar to geodesic colors.
+        float goldenAngleBy2Pi = 0.3819660112501051;
+
+        result.diffuse = hsv2rgb(vec3(float(index) * goldenAngleBy2Pi + 0.3, 1.0, 1.0));
+
+        result.ambient = 0.5 * result.diffuse;
+    }
+#endif
+
+#if num_eyeballs > 0
+    if (ray_hit.object_type == object_type_eyeball) {
+
+#if eyeball_type == 2
+        vec4 pt = ray_hit.ray.point * eyeballInvEmbeddings[ray_hit.object_index];
+        vec3 d = normalize(pt.yzw);
+
+        vec2 tex_coords = vec2(0.5) + vec2(atan(d.x, -d.z) / 2, asin(d.y)) / radians(180);
+
+        result.diffuse = texture(eyeTexture, tex_coords).xyz;
+        result.ambient = 0.5 * result.diffuse;
+#else       
+        result.diffuse = vec3(0.7, 0.7, 0.7);
+        result.ambient = 0.8 * result.diffuse;
+#endif
+    }
+#endif
+
+#if defined(has_edge_midpoints)
+    if (ray_hit.object_type == object_type_edge_midpoint) {
+        result.diffuse = vec3(0.8,0.8,0.3);
+        result.ambient = 0.5 * result.diffuse;
+    }
+#endif
+
     return result;
 }
 
@@ -973,7 +1390,7 @@ vec3 colorForRayHit(RayHit ray_hit)
 
     vec4 light_dir_at_hit = makeUnitTangentVector(
         - light_position, ray_hit.ray.point);
-    
+
     float normal_light = clamp(R13Dot(normal, light_dir_at_hit), 0, 1);
 
     vec4 half_angle = R13Normalise(light_dir_at_hit + ray_hit.ray.dir);
@@ -1045,7 +1462,7 @@ Ray get_ray_eye_space(vec2 xy)
         result.point = R13Normalise(vec4(1.0, 2.0 * xy, 0.0));
         result.dir = vec4(0.0, 0.0, 0.0, -1.0);
     }
-    
+
     return result;
 }
 
@@ -1094,7 +1511,7 @@ leaveVertexNeighborhood(inout RayHit rayHit)
 //
 // The result is true if we are inside a horosphere AND
 // the ray is hitting a peripheral curve on the horosphere.
-// 
+//
 // For optimization, leaveVertexNeighborhood will also apply a
 // parabolic transformation to the ray trying to bring the
 // where we exit the horosphere closer to the entry point.
@@ -1115,7 +1532,7 @@ leaveVertexNeighborhood(inout RayHit rayHit)
                 if (params.y < smallest_p) {
                     // Remember this
                     smallest_p = params.y;
-                    rayHit.object_type = object_type_horosphere;
+                    rayHit.object_type = object_type_horosphere_exit;
                     rayHit.object_index = vertex;
                 }
             }
@@ -1128,13 +1545,13 @@ leaveVertexNeighborhood(inout RayHit rayHit)
             if (params.x == unreachableDistParam) {
                 if (params.y < smallest_p) {
                     smallest_p = params.y;
-                    rayHit.object_type = object_type_margulis_tube;
+                    rayHit.object_type = object_type_margulis_tube_exit;
                     rayHit.object_index = vertex;
                 }
             }
         }
     }
-    
+
     // We are in a horosphere.
     if (smallest_p < unreachableDistParam) {
 
@@ -1152,14 +1569,8 @@ leaveVertexNeighborhood(inout RayHit rayHit)
         // such that the cusp is at infinity
         // Use complex part ignoring height in upper halfspace
 
-        // Map R^2->torus
-        vec2 coords = fract(ml);
-
         // Check whether we hit peripheral curve
-        if (coords.x <       peripheralCurveThickness ||
-            coords.x > 1.0 - peripheralCurveThickness ||
-            coords.y <       peripheralCurveThickness ||
-            coords.y > 1.0 - peripheralCurveThickness) {
+        if (peripheralCurveForMLCoordinates(ml) > 0) {
             // Hit peripheral curve
             return true;
         }
@@ -1167,24 +1578,24 @@ leaveVertexNeighborhood(inout RayHit rayHit)
         // Compute suitable multiple of merdian and longitude translation
         // bringing the exit point into the fundamental parallelogram
         // near zero.
-        vec2 c = -round(ml) * inverse(matLogs[index]);
+        vec2 c = -round(ml) * inverse(toStandardTorusMatrices[index]);
 
         mat4 tsfmCuspSpace =
-            (rayHit.object_type == object_type_horosphere)
+            (rayHit.object_type == object_type_horosphere_exit)
             ? parabolicSO13(c)
             : loxodromicSO13(c);
-        
+
         // Convert O13 matrix from space where cusp was at infinity
         // to space of tetrahedron
         mat4 tsfm =
             tetToCuspMatrices[index] *
             tsfmCuspSpace *
             cuspToTetMatrices[index];
-        
+
         // And apply transformation to ray.
         rayHit.light_source = rayHit.light_source * tsfm;
         rayHit.ray.point = rayHit.ray.point * tsfm;
-        rayHit.ray.dir = R13Normalise( rayHit.ray.dir * tsfm ); 
+        rayHit.ray.dir = R13Normalise( rayHit.ray.dir * tsfm );
 
         // If we are inside a horosphere, leaveVertexNeighborhood has computed
         // the point where we leave the horosphere. But that point
@@ -1218,18 +1629,19 @@ RayHit computeRayHit(vec2 xy){
         graph_trace(ray_tet_space);
     }
 
-    // Check whether we are in a horosphere and if yes,
-    // whether the ray hit a peripheral curve.
-    bool hitPeripheral = leaveVertexNeighborhood(ray_tet_space);
-
-    if (hitPeripheral) {
-        // If we hit a peripheral curve, leaveVertexNeighborhood has given us
-        // the intersection point and we can immediately shade.
-    } else {
-        // In all other cases, we need to raytrace before we shade.
-        ray_trace(ray_tet_space);
+    if (!traceInsideVertexNeighborhood()) {
+        // Check whether we are in a horosphere or Margulis tube and if yes,
+        // whether the ray hit a peripheral curve.
+        if (leaveVertexNeighborhood(ray_tet_space)) {
+            // If we hit a peripheral curve, leaveVertexNeighborhood has
+            // given us the intersection point and we can immediately shade.
+            return ray_tet_space;
+        }
     }
-    
+
+    // In all other cases, we need to raytrace before we shade.
+    ray_trace(ray_tet_space);
+
     return ray_tet_space;
 }
 
@@ -1249,14 +1661,15 @@ vec3 sampleNonGeometricTexture(vec2 fragCoord)
 
 
 void main(){
-     
-    // Show text "Non-geoemtric"
+
+    // Show text "Non-geometric"
     if (isNonGeometric) {
         out_FragColor = vec4(sampleNonGeometricTexture(gl_FragCoord.xy), 1.0);
         return;
     }
 
-    vec2 xy = (gl_FragCoord.xy - 0.5*screenResolution.xy)/screenResolution.x;
+    vec2 xy = (gl_FragCoord.xy - 0.5*screenResolution.xy) /
+         min(screenResolution.x,screenResolution.y);
     if(multiScreenShot == 1) {
         // Return multiple 4096x4096 screenshots that can be combined in, e.g. Photoshop.
         // Here screenResolution is really tileResolution;
@@ -1273,15 +1686,18 @@ void main(){
             vec2 offset =
                 ( vec2(float(1+2*i), float(1+2*j))/float(2*subpixelCount) - vec2(0.5,0.5) )
                 / screenResolution.x / numTiles.x;
-            vec2 scaled_xy = tan(radians(fov * 0.5)) * (xy + offset);
-            
+            vec2 scaled_xy = xy + offset;
+            if (perspectiveType != perspectiveTypeHyperideal) {
+                scaled_xy *= viewScale;
+            }
+
             bool outsideView =
                 perspectiveType == perspectiveTypeHyperideal &&
                 length(scaled_xy) >= 0.5;
 
             if (outsideView) {
                 total_color += vec3(1.0, 1.0, 1.0);
-            } else {            
+            } else {
                 RayHit ray_hit = computeRayHit(scaled_xy);
                 if (ray_hit.object_type != object_type_nothing) {
                     min_depth = min(min_depth, tanh(ray_hit.dist));
@@ -1313,5 +1729,16 @@ void main(){
 
     // Divide by total number of subsamples.
     out_FragColor = vec4(total_color / float(subpixelCount * subpixelCount), 1);
+
+    if (crosshairs) {
+        vec2 coord = gl_FragCoord.xy - floor(0.5 * screenResolution.xy) + vec2(0.5, 0.5);
+        if (abs(coord.x) < 0.1 && abs(coord.y) < 0.1 * screenResolution.x) {
+            out_FragColor.rgb = vec3(1.0) - out_FragColor.rgb;
+        }
+        if (abs(coord.y) < 0.1 && abs(coord.x) < 0.1 * screenResolution.x) {
+            out_FragColor.rgb = vec3(1.0) - out_FragColor.rgb;
+        }
+    }
+
     gl_FragDepth = min_depth;
 }