Baillehache Pascal's personal website

Rendering a textured parametric function in Pov-Ray using the mesh2 object
Memo for myself: a macro to render a textured parametric function in Pov-Ray using the mesh2 object.
#version 3.8;

// Given that you have a parametric expression of the surface a follow:
// Inputs:
//   a, b: two floats, the two parameters of the parametric surface.
//         The range of values for a and b depends on the surface equation
//         but I think it's a good idea to impose it to be [0.0, 1.0] and
//         scale it as necessary here, as it avoid having to adapt the
//         CreateMesh macro below each time you change the FunShape macro
// Output:
//   Return a 3D vector, the coordinates of the surface for the given
//   parameters.
#macro FunShape(a, b)
  <a, cos(a * pi) * sin(b * pi), b>
#end

// In the exact same fashion as for the parametric shape, lets suppose you have
// a parametric expression of the texture components (here I consider only the
// rgb color, but it could be extended as needed to other texture components)
// Inputs:
//   a, b: two floats, the two parameters of the parametric surface (the same
//         as FunShape)
// Output:
//   Return a 3D vector, the rgb color of the surface for the given parameters
#macro FunColor(a, b)
  <a, 0.0, b>
#end

// You may also have an explicit expression of the normals of the surface, but
// if you don't you can get an approximation for free from the surface equation
// as follow:
// Inputs:
//   a, b: two floats, the two parameters of the parametric surface
// Output:
//   Return a 3D vector, the normal vector of the surface for the given
//   parameters.
#macro FunShapeNormal(a, b)
  // shapeEpsilon must be set to a small value in comparison to the range
  // of values for the parameters a and b. Here too, imposing a and b in
  // [0.0, 1.0] avoid having to update shapeEpsilon each time FunShape changes
  #local shapeEpsilon = 0.01;
  vcross(
    FunShape(a + shapeEpsilon, b) - FunShape(a, b),
    FunShape(a, b + shapeEpsilon) - FunShape(a, b))
#end

// The macro creating the textured mesh2 object from the parametric expression
// of your surface and texture
#macro CreateMesh()
  // Define the resolution of your grid, the higher the nicer the heavier
  #local nbStepU = 100;
  // You'd probably like to set the same resolution along the two parameters
  // but nothing forbid choose different ones
  #local nbStepV = nbStepU;
  // Starts the mesh2 object
  mesh2 {
    // Calculate the number of vertices
    #local nbVertex = (nbStepU + 1) * (nbStepV + 1);
    // Start the vertices definition
    vertex_vectors {
      nbVertex,
      // Loop on the steps along the parameters
      #local a = 0;
      #while (a <= nbStepU)
        #local b = 0;
        #while (b <= nbStepV)
          // Get the parameters in [0.0, 1.0] from the current steps and
          // calculate and add the coordinates of the vertex
          FunShape(a / nbStepU , b / nbStepV)
          #local b = b + 1;
        #end
        #local a = a + 1;
      #end
    // End the vertices definition
    }
    // Start the normals definition
    normal_vectors {
      // There is one normal per vertex, hence the reuse of nbVertex
      nbVertex,
      // Loop on the steps along the parameters
      #local a = 0;
      #while (a <= nbStepU)
        #local b = 0;
        #while (b <= nbStepV)
          // Get the parameters in [0.0, 1.0] from the current steps and
          // calculate and add the normal
          FunShapeNormal(a / nbStepU , b / nbStepV)
          #local b = b + 1;
        #end
        #local a = a + 1;
      #end
    // End the normal definition
    }
    // Start the textures definition
    texture_list {
      // There is one texture per vertex, hence the reuse of nbVertex
      nbVertex,
      // Loop on the steps along the parameters
      #local a = 0;
      #while (a <= nbStepU)
        #local b = 0;
        #while (b <= nbStepV)
          // Get the parameters in [0.0, 1.0] from the current steps and
          // calculate and add the texture. Here it could be extend with
          // other parametric functions for the finish{} parameters for
          // example
          texture { pigment { rgb FunColor(a / nbStepU , b / nbStepV) }}
          #local b = b + 1;
        #end
        #local a = a + 1;
      #end
    // End the textures definition
    }
    // Start the faces definition
    face_indices {
      // Get the number of faces, one step along the two parameters defines a
      // polyline of 4 vertices which can be split in two triangles
      #local nbFace = nbStepU * nbStepV * 2;
      nbFace ,
      // Loop on the steps along the parameters
      #local a = 0;
      #while (a < nbStepU)
        // There are two ways to split the polyline in two triangles, alternating
        // regularly between them gives much better visual results. Set a flag
        // to manage that.
        #local flipEdge = mod(a, 2);
        #local b = 0;
        #while (b < nbStepV)
          // Calculate the indices of the four vertices of the polyline
          // corresponding to the current steps
          #local indexVertices = array {
            a * (nbStepV + 1) + b,
            a * (nbStepV + 1) + b + 1,
            (a + 1) * (nbStepV + 1) + b,
            (a + 1) * (nbStepV + 1) + b + 1,
            };
          // Switch between the two ways of splitting the polyline
          #if (flipEdge = 0)
            // Add the first face definition
            <indexVertices[0],indexVertices[1],indexVertices[3]>,
            // Add the texture indices, as we have conveniently defined the
            // texture in the same order as the vertices, their indices are
            // identical
            indexVertices[0],indexVertices[1],indexVertices[3]
            // Same for the second face definition
            <indexVertices[0],indexVertices[3],indexVertices[2]>,
            indexVertices[0],indexVertices[3],indexVertices[2]
          #else
            // Same as flipEdge=1 but with the other combination of indices
            <indexVertices[0],indexVertices[1],indexVertices[2]>,
            indexVertices[0],indexVertices[1],indexVertices[2]
            <indexVertices[1],indexVertices[3],indexVertices[2]>,
            indexVertices[1],indexVertices[3],indexVertices[2]
          #end
          // Flip the splitting
          #local flipEdge = 1 - flipEdge;
          #local b = b + 1;
        #end
        #local a = a + 1;
      #end
    // End the faces definition
    }
  // End the mesh2 object
  }
#end

// Instantiate the mesh
object {
  CreateMesh()
  translate -0.5*x-0.5*z
}

// Dummy settings for test rendering
global_settings {assumed_gamma 1.0}
background { color rgb 12.0 / 15.0 }
camera { location 1.5 look_at 0 }
light_source { 1.5 color rgb 1 }
The result image:
2021-11-25
in All, Computer graphics, POV-Ray,
98 views
You've liked this article ? Please consider supporting me: