3D Geometry and Attribute Modeling 101

Geometry Modeling

A VAO and the VBOs it references

glDrawArrays(mode, start, nVertices);

glDrawElements(mode, nVertices, vertexIndexType, vertexIndices)

Low-level OpenGL Considerations and Tools
- Recall OpenGL only knows how to render points, lines, and triangles. There are several organizational structures for triangles (e.g., individual, strips, fans). We saw in the DrawModes page on the OpenGL web site that triangle strips in particular could be very versatile, both in 2D and in 3D. Be sure to review that page when designing your geometry.
- In addition to coordinates for vertices in the model, we will also need to provide normal vectors to drive the lighting model as we will see shortly: While the normal vector is best treated as a per-vertex attribute, there are times when it is useful to treat it almost as if it were a per-primitive attribute. The glDrawElements page linked below shows a typical example: modeling a cube. It will become clear while studying that example what we mean by "treat it almost as if it were a per-primitive attribute". By contrast, we will see why it is important to treat it as per-vertex when we study the makeXAxisCylinder example below.
- You place vertex coordinates, normal vectors, and whatever other per-vertex attributes you need in parallel VBOs and associate them with a VAO as shown in the top figure on the right.
- You will generally use one of two API functions during display callbacks (i.e., in your render methods) to actually draw geometry defined in this VAO-VBO collection:
  - glDrawArrays(mode, start, nVertices);
    As shown in the middle figure on the right, this function allows you to draw geometry defined by an arbitrary contiguous subset of the data in three VBOs.
  - glDrawElements(mode, nVertices, vertexIndexType, vertexIndices)
    "vertexIndices" will either be an array of length "nVertices" of the indicated "vertexIndexType", or it will be nullptr. If nullptr, OpenGL will get the "nVertices" vertex indices of the indicated "vertexIndexType" from a GPU-resident "element buffer". This option will be fully explained in the glDrawElements page linked below.
    As shown in the bottom figure on the right, this function allows you to use the vertices in the VBOs in a completely arbitrary order based on the specified vertex indices.
    
    Carefully read this glDrawElements reference page for further details, examples, and typical use cases.
Creating the actual coordinate and normal vector arrays:
- Just as we saw with our earlier mountain village example, it is helpful to sketch your general idea, decide where the coordinate origin is to be placed and the direction of the axes.
- Use realistic values for dimensions of things in your scene, paying special attention to relative sizes of objects. If you are modeling your kitchen, for example, pay attention to the height of the ceiling, the sizes of tables and chairs with respect to the room dimensions, and so forth.
- In addition to hard-wiring coordinates and normal vectors into static arrays, you can:
  - Read geometry data from a file, either a standard file format like OBJ, PLY, etc., or design and use a format of your own as you saw in the mountainvillage sample program.
  - Dynamically allocate arrays and fill them with computed coordinate and normal data. We saw examples of doing this with the simple sine-cosine parameterization of a circle in the colorwheel and bowtie sample programs. Below is pseudocode that illustrates how to extend this idea to create a cylinder that lies along the x-axis. Trivial changes can be made to produce such a cylinder that is parallel to (but not necessarily along) the x-axis and/or cylinders along or parallel to the y- or z-axes. Better yet, using the cryph toolkit, it is very easy to write a single such function that will create a cylinder in any arbitrary position and orientation. The code need be no more than a couple lines longer than what is shown here.
```
makeXAxisCylinder(x1, x2, r, nPoints)
{
    // nPoints around a cylindrical slice; must be at least 4
    // since the last point on a slice must be a copy of the first.
    theta = 0;
    dTheta = 2π/(nPoints-1)
    // Each trip through the loop will produce two points: one at
    // the base of the cylinder (x=x1) and one at the top (x=x2):
    for (i=0 ; i<2*nPoints ; i+=2)
    {
        ny = r*cos(theta)
        nz = r*sin(theta)
        vboPts[i] = (x1, ny, nz)
        vboPts[i+1] = (x2, ny, nz)
        // ny and nz also specify the normal vector along this ruling:
        vboNormals[i] = vboNormals[i+1] = (0, ny, nz)
        theta += dTheta
    }
    // Then create the VAO and VBOs you need, filling them with the
    // data you just computed.
}
```
    In the render method for the class containing this cylinder, you use a single glDrawArrays call to render the entire cylinder (sans end caps): glDrawArrays(GL_TRIANGLE_STRIP, 0, 2*nPoints);
Be sure your ModelView subclasses always implement getMCBoundingBox correctly! The general viewing strategy we use depends upon that!
Sometimes we want to create one model by combining various "sub-models". There are several ways to do this. Here are two:
1. One ModelView class can be designed to use one or more completely independent classes. These independent classes may or may not themselves by ModelView subclass instances. You will notice that starting with SampleProgramSet3, the render method in all ModelView classes is structured roughly as follows:
```
void SomeModelViewClass::render()
{
    <Save current GLSL program in 'pgm'; establish GLSL program; establish global viewing and lighting>

    renderXxx(<maybe some parameters>);

    glUseProgram(pgm);
}

void SomeModelViewClass::renderXxx(<maybe some parameters>)
{
    <do actual rendering of object, assuming all global context is established>
}
```
  Both render and renderXxx are public methods. With this design, an instance of SomeModelViewClass can be created and added to the Controller in the usual way.
  OR
  
  Some other class instance can create one or more instances of this class, not add them to the Controller, and then call their renderXxx method, without calling their render method at all. When used this way, such objects are NEVER added directly to the Controller; rather their renderXxx methods are simply called directly from their "owning" ModelView subclass' render method as needed. Only the actual top-level ModelView instance is added to the Controller.
  
  For examples, see CGLString or BasicShapeRenderer.
  
  Note that while render is required of any concrete ModelView subclass, the implementation structure of render shown here – and in particular the use of renderXxx – is simply a design pattern that is quite useful. There is no framework-enforced interface to such a renderXxx.
2. Within one ModelView subclass, you can create an arbitrary number of VAO-VBO collections. When the model is constructed, you create all the VAO/VBO instances. When the render method is called, each VAO is bound in turn, and one or more glDrawArrays and/or glDrawElements calls are made using each such bound VAO. You may even choose to use different GLSL programs during this process.
  For an example, review the basketball example.

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.

We only will present those attributes needed for project 2. We will return to this topic in 3D Geometry and Attribute Modeling 102 later.

PVAs: coordinates and normal vectors (discussed above)
PPUs: 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}
These values are interpreted as the fraction of incident light of the indicated wavelength that is reflected.
Strategies for specifying PPU reflectance properties
- For now, we will assume that k_a = k_d
- For now, you can obtain reasonable color values using any of the techniques we saw in the Interlude: Color Spaces and Color Selection in the sample program set 1 web page. We will explore some other possibilities as we elaborate on the lighting model.