3D Geometry and Attribute Modeling 102

As we stated in 3D Geometry and Attribute Modeling 101, there are three important modeling tasks to address when we design a scene:

1. Geometry modeling: create the geometry of the points and vectors that define the surfaces and other elements in our 3D scene.
2. Attribute modeling: define the attributes associated with the vertices and primitives in our geometry.
3. The lighting environment. This often overlooked item is frequently the key to a really good scene rendering.

Geometry Modeling

• Some hints for higher-level techniques
  • Piecewise linear approximation is a tool we can use on the CPU or on the GPU (in tessellation and/or geometry shaders). Note that we must generate both the 3D vertex coordinates and the corresponding 3D normal vectors for each vertex. Again, the cryph utilities can go a long way towards simplifying the code required for these.
    • Quadric surfaces (most commonly, cylinders, spheres, and cones):
      
      The required code for all three of these is a straightforward extension of what we saw in the colorwheel example. Computing the normal vectors for the cylinder and the sphere is straightforward. Computing the normal to a cone is only slightly more complex and can be done in a couple of different ways. For example, the normal at a point, P, to a cone whose vertex is V and whose axis vector is a is just the component of a perpendicular to (P - V).
    • Terrain surfaces (aka height or elevation surfaces):
      
      These are surfaces that can be written in the form:
      z = f(x, y) They can also be written as an implicit equation:
      F(x, y, z) = f(x, y) - z = 0 Using the implicit equation, we can express the normal vector at a point on the surface as: normal(x, y, z) = ∇F(x, y, z).

      You usually create such a surface over a rectangular domain in the xy-plane, something like:

      for (double x=xmin ; x<=xmax ; x+=dx)
          for (double y=ymin ; y<=ymax ; y+=dy)
          {
              cryph::AffPoint p(x, y, f(x,y));
              cryph::AffVector normal(gradientOfF(x,y));
              // store p and normal in their respective VBOs
          }

      The surface above was generated from z = f(x, y) = cos(x² + y²).

      Recalling your calculus days, you implement gradientOfF(x,y) = ∇(f(x,y) - z) = ((∂f/∂x)(x,y), (∂f/∂y)(x,y), -1).

      In the case of our surface above, ∇(f(x,y) - z) = ((∂f/∂x)(x,y), (∂f/∂y)(x,y), -1) = (-2xsin(x² + y²), -2ysin(x² + y²), -1).

      Sometimes height surfaces are only known discretely. The most common example could be characterized as a 2D array representing a grid covering some region of the xy-plane in which we know the height only at each point of the array. This structure is easily mapped to a collection of OpenGL triangle strips. The normal at each vertex could be computed either as the average of all triangle normals sharing the vertex, or as the normal to a single triangle. As an example of the latter, the normal at vertex [r][c] might come from the triangle with vertices [r][c], [r+1][c] and [r][c+1], with proper care being taken for boundary cases.

• Structure
  • Concrete subclasses of ModelView/SceneElement can be constructed using the BasicShape and BasicShapeRenderer classes. See the full documentation and examine the room example in SampleProgramSet3 that uses these classes. BasicShape instances create building block objects like spheres, blocks, and cones. Class BasicShapeRenderer is a "renderable object" that can then render these shapes in some scene. Recall the discussion in 3D Modeling 101 where we explained the structure of render methods that establish the environment and then call "renderXxx" methods – either their own or those of other classes.

Attribute Modeling

Some model attributes need to be per-vertex; others are per-primitive. We are focusing on attributes related to the lighting model here, and they are most commonly done as per-primitive. Hence that will be our approach here.

• Surface reflectance properties
  • Ambient: k_a=(k_ar, k_ag, k_ab)  ––  0 ≤ k_ac ≤ 1, c ∈ {r, g, b}
  • Diffuse: k_d=(k_dr, k_dg, k_db)  ––  0 ≤ k_dc ≤ 1, c ∈ {r, g, b}
  • Specular:
    k_s=(k_sr, k_sg, k_sb)  ––  0 ≤ k_sc ≤ 1, c ∈ {r, g, b}
    m, a glossiness factor, implemented as an exponent on the specular reflection term in the Phong lighting model.
• Strategies for specifying
  • Pick a base color along with ambient, diffuse, and specular scale factors
    • Many ways to choose a base color. For example: Sample program set 1's interlude on color.
    • A special case: white highlights on black objects.
  • Never set glossiness factor (specular exponent, m) to zero (unless, perhaps, you also set k_s=(0, 0, 0)). Otherwise there will be a discontinuous jump from no specular to full specular on surfaces. The specular exponent, m, should always be at least 1.0.
  • Phong Model Material Properties for a collection of common materials