In this lab, we’re going to use bilinear interpolation to deform a 2D mesh.
Please download the lab and go over the code.
When you compile and run the source code, you should see a 2D figure with a cage around it. The cage is draggable, but it won’t do anything until you implement a couple of functions. You can change the grid size by modifying grid->setSize() in the init() function in main.cpp.
Set the grid size back to (2, 2) to get a 2 by 2 array of grid points. Take a look at the function ShapeCage::load(). The posBuf vector is being filled with the data from the obj file. In the ShapeCage::toLocal() function, which is called once at the beginning of the program, this data is being passed through without modification to the posLocalBuf vector, and in the ShapeCage::toWorld() function, which is called every frame, this data is being passed back to the posBuf vector. (Note that posBuf is of size 3*nVerts, since it comes from the input obj file, whereas posLocalBuf is of size 2*nVerts, since only the 2D local coordinates are stored.) This obviously does nothing when the grid moves. What you want to do instead is to properly compute the local coordinates and then compute the world coordinates from the local coordinates PLUS the new grid configuration.
First, implement the ShapeCage::toLocal() function. For now, since there is only one tile in the grid, you can ignore the tileIndexBuf vector. (We will be using this later when we increase the grid size.) For each vertex, posLocalBuf should store where that vertex is with respect to the grid tile — i.e., its local coordinates. To get the four control points of the 0th tile (currently our one-and-only tile), use the following:
vector<glm::vec2> cps = grid->getTileCPs(0);The returned vector cps contains the four control points in this order:
To compute the local coordinates (u, v) of a vertex, get the minimum and maximum (x, y) world coordinates of the tile, and then use the following formula:
\[ u = \frac{x - x_\min}{x_\max - x_\min}, \qquad v = \frac{y - y_\min}{y_\max - y_\min}. \]
Once the local coordinates are computed properly, you should see the character in the top right corner as shown. This is because the world goes from (-1, -1) to (1, 1), and the local coordinates are between 0 and 1. Once we implement toWorld() in the next task, the character will fill the whole tile again.
Now implement ShapeCage::toWorld(). In this function, you should do the reverse of the transformation you applied above so that the posBuf vector is filled with proper values. In other words, for each vertex, apply the bilinear interpolation function:
\[ \begin{aligned} & P_0(u) = (1 - u) P_{00} + u P_{01},\\ & P_1(u) = (1 - u) P_{10} + u P_{11},\\ & P(u,v) = (1 - v) P_0(u) + v P_1(u). \end{aligned} \]
You can get the four control points, \(P_{00}\) through \(P_{11}\) with the call to grid->getTileCPs(0) as before. You should now be able to move the character by moving the control points.
Increase the grid size to (5, 5). Since there are multiple tiles now, the current code does not work. You need to change both ShapeCage::toLocal() and ShapeCage::toWorld().
In ShapeCage::toLocal(), you need to find which tile each vertex belongs to by looping through all of the tiles. You can do this with a double for-loop using the nrows and ncols variables and a call to grid->indexAt(row, col).
// Find which tile this vertex belongs to
for(int col = 0; col < ncols-1; ++col) {
for(int row = 0; row < nrows-1; ++row) {
// Get the four control points for corresponding to (row, col)
int tileIndex = grid->indexAt(row, col);
vector<glm::vec2> cps = grid->getTileCPs(tileIndex);
//
// DO SOME STUFF HERE
//
}
}Keep in mind that nrows and ncols are the number of control points in the x and y directions, and so the number of tiles is nrows-1 by ncols-1. The tile index takes on the value of the control point at its lower left corner. For example, if nrows=3 and ncols=3, then the tile indices are:
In addition to the local coordinates, each vertex needs to store the tile index. Store this in the tileIndexBuf vector. Note that the length of this vector is nVerts, whereas the length of posLocalBuf is 2*nVerts.
In ShapeCage::toWorld(), you should use both tileIndexBuf and posLocalBuf to compute the updated posBuf. First find the four control points you need from the tile index of the vertex. Then use bilinear interpolation to find the world coordinates of the vertex. You should now be able to move the numerous control points to pose the character.
Now we’re going to implement bilinear interpolation on the GPU. You should add a keyboard hook to switch between the CPU and the GPU versions.
The ShapeCage::toLocal() function is going to remain the same. However, you will no longer be needing the ShapeCage::toWorld() function, since you will be doing this transformation in the vertex shader. Think about what you need to do to replace this function with GPU code.
Miscellaneous tips:
Before, you were passing posBuf to the vertex shader as an attribute variable. Now you’ll be passing in posLocalBuf instead. You need to transform these positions from local to world in the vertex shader. Important: posBuf is loaded from the obj file, and so it contains (x,y,z) values for each position, but posBufLocal should only contain (u,v) values. Therefore, the 2nd argument to glVertexAttribPointer() should be 2, not 3.
In addition, you need to pass tileIndexBuf as an attribute variable. You’ll need to use a float rather than an int because some graphics cards do not support integer data types. In GLSL, you can cast a float to int using a C++ style cast.
float bar;
...
int foo = int(bar);You can hard code the grid size in the shader to (5, 5).
You can pass in the 25 control points as a uniform parameter. prog will have to be changed to match whatever variable name you’re using.
// In the vertex shader:
uniform vec2 cps[25];
...
// In main.cpp:
glUniform2fv(prog->getUniform("cps"), 25, glm::value_ptr(grid->getAllCPs()[0]));To access the four control points of the kth tile in the vertex shader:
vec2 cp00 = cps[k];
vec2 cp01 = cps[k + 1];
vec2 cp10 = cps[k + ncols];
vec2 cp11 = cps[k + ncols + 1];You’ll need to add a new argument to ShapeCage::draw() for the tile index attribute array.