The aim here is to cover surfaces with geometric shapes. The surfaces are, of course, three-dimensional. The method used will be applied to a flat surface, then to a cylinder, a sphere and a torus. Another type of surface to cover would be hyperbolic surfaces, as shown on the WIKIPEDIA page. For the moment, I haven't got there yet, although for the "Hyperbolic paraboloid", the geometry remains simple.

- Basic forms - In theory, any polygon can be used, as long as the edges are perpendicular. Here are some examples. You can let your fantasy run wildd. I've opted for the first form to emphasize what I'm saying.

- Shape construction -

Each shape is made up of a set of points. These points are represented by a sphere. The edges are made up of cylinders linking each point in a well-defined order. Finally, the body of the shape is defined by the space inside the set of points and edges. We'll see later how to construct this body. A complete form can be made up of several parts, as shown in the examples above. Each part has a specific color. Parts of the shape can be obtained using rotations, translations and symmetries, but care must be taken with the curvature of the surface on which they are to be positioned.



- Plane tiling -

Let's start with the simplest example. We define the "Size" of each tile making up the shape as well as the radius of the rounding "Round", which will also be the radius of the sphere making up the points and the radius of the cylinders making up the edges.

#declare Size = 1.0;
#declare Round = 0.10;

Next, the number of points and, for each point, the coordinates. All this is stored in a table.

#declare NumberOfPoints = 8;
#declare PointsOfShape = array [NumberOfPoints] {
  <Round, Round, Round>,                // 0
  <Round, Round, Size+Round>,           // 1
  <-Size+Round, Round, Size+Round>,     // 2
  <-Size+Round, Round, 2*Size-Round>,   // 3
  <2*Size-Round, Round, 2*Size-Round>,  // 4
  <2*Size-Round, Round, Size+Round>,    // 5
  <Size-Round, Round, Size+Round>,      // 6
  <Size-Round, Round, Round>            // 7
  }

Note the addition or removal of radius "Round" for each point. In the plane there's no curvature so, the body of the shape is a simple prism. We can create a macro to build the complete shape, a simple assembly of spheres, cylinders and prism. The array containing all the points is passed to the macro as a parameter.

#macro BuildShape (p) // p : array of points
  #local n = dimension_size(p,1);
  #local r = p[0].y;
  union {
    // --- spheres ---
    #local i = 0;
    #while ( i < n )
      sphere { p[i], r } 
      inc(i)
    #end
    // --- cylinders ---
    #local i = 0;
    #while ( i < n )
      cylinder { p[i], p[mod(i+1,n)], r } 
      inc(i)
    #end
    // --- prism ---
    prism {
      // default linear_spline
      p[0].y-r, // lower y
      p[0].y+r, // upper y
      n+1,     // number of points
      #local i = 0;
      #while ( i < n )
        <p[i].x, p[i].z>, 
        inc(i)
      #end
      // --- to avoid message about closing
      <p[0].x, p[0].z>
      }
    }
#end

We then obtain :


Here, we are on the plane, so . The complete shape can be obtained with rotations and translations. Finally, we have :

#declare TheShape = union {
  object { Shape pigment { color Color1 } }
  object { Shape rotate 90*z translate Size*<3,1,0> pigment { color Color2 } }
  object { Shape rotate 180*z translate Size*<2,4,0> pigment { color Color1 } }
  object { Shape rotate 270*z translate Size*<-1,3,0> pigment { color Color2 } }
  }

Covering the plane with this shape is then done using two nested loops :

#declare ThePlane = union {
  #declare xIndex = xMin;
  #while ( xIndex < xMax )
    #declare zIndex = zMin;
    #while ( zIndex < zMax )
      object {
        TheShape
        translate zIndex*(4*Size)*z
        translate xIndex*(4*Size)*x
        }
      inc(zIndex)
    #end
    inc(xIndex)
  #end
  }

- Cylindrical tiling -

For this shape, everything said above remains valid. The difference is that the "horizontal" rods are no longer cylinders, but arcs of a torus. Vertical rods are still cylinders, as there is no curvature in this direction (we assume that the cylinder axis is the y-axis). We now need to use two new variables. The other variables remain unchanged. The radius "Radius" of the cylinder and the angle in degrees "Angle" to define the shape :

#declare Angle = 8; // in degrees
#declare Radius = 8;

The table still contains the coordinates of the points, but they are defined directly on the cylinder (with a little trigonometry) in this way :

#declare Points[0] = <Radius*cosd(-1.5*Angle), Round, Radius*sind(-1.5*Angle)>;
#declare Points[1] = <Radius*cosd(-1.5*Angle), Size, Radius*sind(-1.5*Angle)>;
#declare Points[2] = <Radius*cosd(-0.5*Angle), Size, Radius*sind(-0.5*Angle)>;
#declare Points[3] = <Radius*cosd(-0.5*Angle), 2*Size, Radius*sind(-0.5*Angle)>;
#declare Points[4] = <Radius*cosd(+0.5*Angle), 2*Size, Radius*sind(+0.5*Angle)>;
#declare Points[5] = <Radius*cosd(+0.5*Angle), 1*Size, Radius*sind(+0.5*Angle)>;
#declare Points[6] = <Radius*cosd(+1.5*Angle), 1*Size, Radius*sind(+1.5*Angle)>;
#declare Points[7] = <Radius*cosd(+1.5*Angle), Round, Radius*sind(+1.5*Angle)>;

As I said earlier, vertical rods are still cylinders, but horizontal rods require the creation of arcs of torus. The general way to obtain a torus arc is :

difference {
  torus { Radius, Round }
  plane { z, 0 rotate +0.5*Angle*y }
  plane { z, 0 rotate -0.5*Angle*y inverse }
  }

Once the points and edges have been built, we need to deal with the body. Just like "torus arcs", we need to create "cylinder arcs". This part is obtained in this way and is very similar to the data above :

difference {
  cylinder { <0, Size, 0>, <0, 2*Size, 0>, Radius+Round }
  cylinder { <0, Size-1, 0>, <0, 2*Size+1, 0>, Radius-Round } 
  plane { z, 0 rotate +0.5*Angle*y }
  plane { z, 0 rotate -0.5*Angle*y inverse }
  }

With all of this we get :






- Spherical tiling -

The surface of a sphere is a surface with two identical radii of curvature and the same origin. Meridians are always "great circles". Their radii are equal to the radius of the sphere. The radius of parallels is variable. It depends on latitude and becomes zero at the poles. So we no longer have a "straight" rods. All edges are torus arcs and the body of the shape is a spherical part bounded by two parallels and two meridians.

The table of points still contains the coordinates of the points, but they are defined directly on the sphere using latitude and longitude via a macro.

#macro LonLat2Rectangular (rSphere, Longitude, Latitude)
 #local yy = rSphere*sind(Latitude);
 #local l = rSphere*cosd(Latitude);
 #local xx = l*cosd(Longitude);
 #local zz = l*sind(Longitude);

 #if (sqrt(xx*xx+yy*yy+zz*zz) != rSphere)
  #error "oops something's wrong !"
 #end

#end

The dimensions of the shape are defined not by distances, but by angles. The "SolidAngle" macro is used to construct these sphere pieces. Angles are expressed in degrees. Note also the use of a cone { } to cut out the sphere.

#macro SolidAngle (rSphere, eSphere, Longitude0, Longitude1, Latitude0, Latitude1)
 #local ALong = abs(Longitude0-Longitude1);
 difference {
  sphere { <0,0,0>, rSphere+eSphere }
  sphere { <0,0,0>, RSphere-eSphere }
  plane { z, 0 }
  plane { z, 0 rotate -ALong*y inverse }
  #if ( Latitude1 < 90) 
   cone { <0,0,0>, 0, <0, RSphere*2, 0>, RSphere*2*tand(90-Latitude1) }
  #end   
  cone { <0,0,0>, 0, <0, RSphere*2, 0>, RSphere*2*tand(90-Latitude0) inverse } 
  rotate -Longitude0*y
  }
#end

The rods on the meridians are torus arcs whose radius is equal to the radius of the sphere. For the rods on the parallels, the radius depends on the latitude and can be calculated in this way:

#local RadiusAtLatitude = rSphere*cosd(Latitude);
#local YAtLatitude = rSphere*sind(Latitude);

Finally, we obtain this shape :


On the sphere, arc lengths are not constant. These lengths are easily calculated using the classic formula \( s = r\theta \) with angle in radians. Consequently, the basic shapes cannot be duplicated. At the very least, you'll need to build all the shapes in the same spherical half-moon. As the sphere has many symmetries, this spherical half-moon can be duplicated by rotation, then by several symmetries over the entire surface.

A note about tiling the sphere : At the poles, the length of parallel arcs tends towards zero. It becomes difficult to create the shape. I haven't yet found a satisfactory way of dealing with this case.



- Toroidal tiling -

The torus also has two radii of curvature, but unlike the sphere, the centers of these curvatures are not coincident. And we obtain this shape :