snappy 3.1.1__cp39-cp39-win_amd64.whl → 3.2__cp39-cp39-win_amd64.whl

snappy/raytracing/shaders/fragment.glsl

@@ -26,6 +26,7 @@ out vec4 out_FragColor;
 
 uniform vec2 screenResolution;
 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;
@@ -55,7 +56,7 @@ uniform bool showElevation = false;
 
 layout (std140) uniform TetrahedraCombinatorics
 {
-    int otherTetNums[4 * ##num_tets##]; 
+    int otherTetNums[4 * ##num_tets##];
     int otherFaceNums[4 * ##num_tets##];
 };
 
@@ -89,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##;
@@ -115,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##];
@@ -123,20 +125,72 @@ layout (std140) uniform MargulisTubes
 };
 uniform float margulisTubeRadiusParams[4 * ##num_tets##];
 
-#if ##num_geodesic_segments## > 0
+#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##];
+    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##];
 
+#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.
 uniform float insphereRadiusParams[##num_tets##];
@@ -150,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;
 
@@ -223,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;
@@ -233,18 +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_geodesic_tube       = 11;
+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
@@ -271,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)
@@ -284,17 +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 ||
-        ray_hit.object_type == object_type_geodesic_tube;
+    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).
@@ -304,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);
 }
 
@@ -344,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)
@@ -364,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,
@@ -511,7 +579,7 @@ horosphereEqn(int index)
     return horosphereScales[index] * R13Vertices[index];
 }
 
-#if ##num_geodesic_segments## > 0
+#if defined(num_geodesic_segments) && num_geodesic_segments > 0
 // The two endpoints of a geodesic
 vec4[2]
 endpointsForGeodesic(int index)
@@ -536,19 +604,31 @@ 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));
     }
 
-#if ##num_geodesic_segments## > 0
+    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,
@@ -556,8 +636,44 @@ normalForRayHit(RayHit ray_hit)
     }
 #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) {
@@ -591,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##
@@ -617,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
 
@@ -637,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,
@@ -661,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
 
@@ -712,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;
@@ -720,34 +914,24 @@ 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 (margulisTubeRadiusParams[index] > 0.50001) {
-            vec2 params = distParamsForTubeIntersection(
-                ray_hit.ray,
-                endpointsForMargulisTube(index),
-                margulisTubeRadiusParams[index],
-                0.0);
-
-            if (params.x < smallest_p) {
-                smallest_p = params.x;
-                ray_hit.object_type = object_type_margulis_tube;
-                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 ##num_geodesic_segments## > 0
+#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++) {
@@ -758,7 +942,8 @@ ray_trace_through_hyperboloid_tet(inout RayHit ray_hit)
             geodesicTubeRadiusParam[index],
             0.0);
 
-        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_geodesic_tube;
             ray_hit.object_index = index;
@@ -766,6 +951,87 @@ ray_trace_through_hyperboloid_tet(inout RayHit ray_hit)
     }
 #endif
 
+#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++) {
+
+        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.500001) {
@@ -774,7 +1040,7 @@ ray_trace_through_hyperboloid_tet(inout RayHit ray_hit)
         float backDistParam = 0.0;
 #else
         float backDistParam = tanh(ray_hit.distWhenLeavingCusp-ray_hit.dist);
-#endif    
+#endif
 
         for (int edge = 0; edge < 6; edge++) {
 
@@ -784,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;
@@ -799,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;
+                }
             }
         }
     }
@@ -844,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 =
@@ -863,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 ];
     }
 }
@@ -928,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];
 
@@ -946,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;
         }
@@ -980,7 +1254,7 @@ 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
@@ -1001,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;
@@ -1017,7 +1291,7 @@ material_params(RayHit ray_hit)
         result.ambient = 0.5 * result.diffuse;
     }
 
-#if ##num_geodesic_segments## > 0
+#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];
 
@@ -1040,6 +1314,44 @@ material_params(RayHit ray_hit)
     }
 #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;
 }
 
@@ -1078,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);
@@ -1150,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;
 }
 
@@ -1199,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.
@@ -1220,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;
                 }
             }
@@ -1233,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) {
 
@@ -1257,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;
         }
@@ -1272,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
@@ -1323,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;
 }
 
@@ -1354,8 +1661,8 @@ 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;
@@ -1383,14 +1690,14 @@ void main(){
             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));
@@ -1422,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;
 }