Upcoming Events
Unite 2010
11/10 - 11/12 @ Montréal, Canada

GDC China
12/5 - 12/7 @ Shanghai, China

Asia Game Show 2010
12/24 - 12/27  

GDC 2011
2/28 - 3/4 @ San Francisco, CA

More events...
Quick Stats
103 people currently visiting GDNet.
2406 articles in the reference section.

Help us fight cancer!
Join SETI Team GDNet!
Link to us Events 4 Gamers
Intel sponsors gamedev.net search:

VCP Mirror Theory

The following are the list of steps to be done to implement such a VCP reflection properly:

  1. Set up a render target. E.g. a texture
  2. Calculate the reflection matrix
  3. Compute the VCP from the reflection matrix
  4. Compute the perpendicular distance of the camera from the mirroring plane in world space
  5. Compute rotation matrix to rotate the mirror plane so that it aligns with the x-y plane (e.g. parallel with x-y plane)
  6. Use previous rotation matrix to rotate VCP by the same amount
  7. Translate mirror vertices by the magnitude of the VCP –x, –y and –z values
  8. Compute resultant min/max x and y mirror vertices coordinates
  9. Set up projection matrix using the results from step 4 and step 8
  10. Point virtual camera from original VCP to world space coordinate of the real camera, and compute the view matrix
  11. Render the scene using the virtual camera's position, projection and view matrix

In the implementation of the VCP mirror; I used the Direct3DX miscellaneous function D3DXCreateRenderToSurface to get an ID3DXRenderToSurface interface. The ID3DXRenderToSurface interface could be used to attach a texture surface, which can then be used as the render target easily.

The reflection matrix in step 2 can be easily calculated using the D3DXMatrixReflect function in Direct3D. This matrix is really handy as you could easily get the VCP by multiplying it with the current camera world space position. The multiplication has the same effect of flipping the point at the current camera position to the VCP in world space. The reflection matrix simply inverts the coordinate system on the other side of the mirroring plane. It's a variation of the common identity matrix. So if the y-z plane were the mirroring plane, then the reflection matrix would have a diagonal of {1, -1, 1}, which inverts the y-axis appropriately. The following is the reflection matrix for a mirroring plane on the y-z plane:

Step 4 computes the perpendicular distance of the camera from the mirroring plane in world space. We need a vector from one of the mirror vertex to the camera position lets call it a. We also need another vector representing the normal of the mirroring plane lets call it n. Normal n could be calculated easily by the cross product of any of the mirror's two edges. A vector projection of vectors a on n will then yield the perpendicular distance we need.

Figure 3: Vector Projection to Find Perpendicular Distance

Figure 3 shows the vector projection to find the perpendicular distance. In mathematical notation, the vector projection would be as follows:

This is just the dot product of vector a with normalized n. Alternatively, the VCP calculated in step 3 could be used to replace the camera position when calculating a but you would need to be careful with the signage of the resultant scalar distance. If the distance is negative, the camera is behind the mirror; hence steps 5 to 11 can be skipped.

Steps 5 to 7 are meant for converting the mirror and the virtual camera (at VCP) from world space to camera space (eye space for OpenGL jargon). In camera space, the virtual camera, should sit on the origin. Step 5 involves standard vector dot product arithmetic and some vertex rotations. We need to rotate the mirror vertices twice: once about the x-axis and once about the y-axis. The reason for doing this is to align the mirror's vertices with the x-y plane. The angle to rotate about the x-axis comes from the dot product of the mirror up vector and the y-axis. The angle to rotate about the y-axis comes from the dot product of the mirror's "Left-To-Right" vector with the x-axis. The "Left-To-Right" vector can be computed using the lower left mirror vertex and the lower right mirror vertex. The two rotations are combined into a rotation matrix so that we can just multiply the mirror vertices with it to effect the combined rotation. We have to be very careful when it comes to computing the rotation about the y-axis. We need to ensure that after rotation, the virtual camera would be facing the +ve z direction; if you are using a Right-Hand coordinate system as in OpenGL then it's the -ve z direction. This is a must because the projection matrix calculation in step 9 would not work if the virtual camera does not face the +ve z direction. In fact, all projection matrix calculation for Left Hand coordinate system assumes that the camera is looking at the +ve z direction! Again the assumption for Right Hand coordinate system is –ve z direction. We can make sure that our virtual camera, when rotated, faces the +ve z direction by testing the z coordinate value of the mirror's normal after it had been rotated by the rotation matrix calculated earlier on. The mirror's normal is the same as the direction of the virtual camera. We multiply it with the computed rotation matrix and check the rotated normal. The signage of the z coordinate of the rotated normal tells you whether the virtual camera will be facing +ve or –ve z direction. If the z coordinate of the rotated normal is –ve (facing –ve z direction), we would need to re-compute the rotation matrix by negating the angle to rotate about the y-axis. The following figure sums up this paragraph, I hoped.

Figure 4: Ensuring the Virtual Camera Faces +ve z Direction After Rotation

Step 6 uses the previous rotation matrix to rotate the virtual camera at VCP by the same amount as the mirror vertices. Remember that the rotated virtual camera must face +ve z for Left Hand coordinate system (DirectX) and –ve z for Right Hand coordinate system (OpenGL).

Step 7 involves negating the x, y and z components of the rotated VCP and then translating the mirror vertices (already parallel with the x-y plane) using the negated values. This has the effect of translating the mirror vertices by the same magnitude needed to move the VCP to the origin. The conversion from world space to camera space is now complete and we can start computing the projection matrix. Figure 5 shows the mirror vertices being rotated for alignment with the x-y plane and then translated (to camera space).

Figure 5: Transforming Mirror From World Space to Camera Space

Step 8 basically grabs the min/max x and y coordinates from the mirror vertices in camera space (e.g. after the rotation and translation).

Step 9 is where we formulate a matrix to represent the projection that we want in camera space. The values needed are the min/max x and y values, the near clip and the far clip. The near clip is the perpendicular distance calculated in step 4. The far clip would depend on how far, or how "deep", you want the reflection to be. Normally this should be a large value or at least matching the far clip value of any custom view frustum. You could compute the projection matrix with the above ingredients using formulas or you could simply use the D3DXMatrixPerspectiveOffCenterLH function in DirectX. Figure 6 below shows the graphical depiction of such a projection in camera space.

Figure 6: Projection in Camera Space

Step 10 computes the view matrix for the virtual camera. The purpose of the view matrix in DirectX is to collate the orientation and position of the viewer. Our viewer in this case is the virtual camera at the VCP. To compute the correct view matrix for the virtual camera, simply "point" the virtual camera at the original camera in world space. Take a look at Figure 7 below, which shows the top view of the off center projection and the view of the virtual camera.

Figure 7: Top View of Projection and View of Virtual Camera

Again, you have the option of applying the full formulas to compute the view matrix. But it can be done easily with the D3DXMatrixLookAtLH function, which is again meant for left hand coordinate system. Use the D3DXMatrixLookAtRH function if you are using right hand coordinate system. A point to note here is that the up vector required by the D3DXMatrixLookAtLH function should be the world up vector, which is usually the y-axis. Do not use the up vector of the camera. This is because when the camera rotates, the reflection in the mirror should not be rotating, it should be fixed. Hence the use of the world up vector, which should be fixed all the time, I hoped.

Lastly set the world and view matrices (e.g. pDevice->SetTransform(D3DTS_WORLD, mat) in DirectX) and render the scene to the texture surface that we had prepared in step 1. You had just completed the 1st rendering pass! The 2nd pass is just drawing the entire scene including the mirror, which can now be textured with the nice reflection texture you rendered previously. :-)

The following are some screen shots of incorrect and correct reflections generated using the VCP technique. The reasons for the inaccuracies will be explained later.

Figure 8: Incorrect Reflection Generate Using VCP

Figure 9: Obvious Inaccuracies in Reflection Generated Using VCP

Figure 8 and Figure 9 show two screenshots during the implementation of the VCP sample. Figure 8 seems to be a correct reflection but is actually wrong. With the mirror standing perpendicularly and bottom touching the floor, the orientation and mismatching of the floor textures gives a good hint that the reflection is wrong. Figure 9 shows a much more obvious screen capture of the same implementation. The floor reflection is totally wrong and the scene appears a little skewed towards the bottom of the mirror. The errors were traced to the incorrect calculation of the projection matrix. A wrong projection matrix would easily cause an incorrect reflection as shown in Figure 10 below and it is not easy to trace such an error if the projection is just off marginally.

Figure 10: Incorrect Off Center Projection Calculation

Now lets take a look at some of the screen captures of correct reflections generated in the sample.

Figure 11: Correct Perspective VCP Reflection

Notice the correct reflection of the floor immediately in front of the mirror. Since the mirror's bottom edge is touching the floor, the reflection should be as depicted in Figure 12 above instead of the one in Figure 9. The next screen captures shows another accurate reflection generated from an elevated viewing position.

Figure 12: Correct VCP Reflection on Floor Textures

Ok! That's all for VCP reflections. Fire up your favorite development environment or editor and start coding!


  1. DirectX SDK8.1 Documentation
  2. Beginning Direct3D Game Programming, Premier Press, 2001, ISBN: 0-7615-3191-2, Wolfgang F. Engel, Amir Geva and Andre LaMothe.
  3. Direct3D ShaderX Vertex and Pixel Shader Tips and Tricks, Wordware Publishing Inc, 2002, Wolfgang F. Engel.
  4. Realtime Rendering, 1st Edition, A K Peters Ltd, 1999, ISBN: 1-56881-101-2, Tomas Moller, Eric Haines.
  5. Flipcode IOTD 1st September 2002: http://www.flipcode.com/cgi-bin/msg.cgi?showThread=09-01-2002&forum=iotd&id=-1
  6. Robsite for MilkShape 3D tutorials: http://www.robsite.de/tutorials.php?tut=milkshape

  7. 3D Total website for the textures: http://newsite.3dtotal.com/

  8. Philip Taylor's Exploring D3DX part2: Textures, Microsoft Corp, http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dndrive/html/directx08202002.asp
  9. Texture Mapping brief, http://www.bol.ucla.edu/~dremba/3dg_texture_mapping.htm

  VCP Mirror Theory

  Source code
  Printable version
  Discuss this article