Modeling Realistic 3D Objects

CS 493/693 Lecture, Dr. Lawlor

So to model real-world objects, you need a modeling program.

Blender is a pretty capable free 3D modeling program. It's available for all platforms. The only downside is the bizarre, nonstandard user interface. This is typical for 3D modeling programs, even pro versions--they're just their own weird thing. Start with the official installer (use the .zip option on the Chapman lab machines, since the .exe installer needs admin access).

Check out the Blender Tutorials and Blender Doc Wiki. In particular, I've worked over the Volcano Tutorial to the point where it almost makes sense. Here's my super-compressed cheat sheet:

Left-click manipulates the currently selected object with the current tool. It often does nothing.
Middle-click (or left and right simultaneously) rotates in 3D. Control-middle-click zooms in.
Right-click selects.
Spacebar brings up a context-sensitive menu.
"Object mode" lets you translate, scale, rotate entire objects (arrange models).
"Edit mode" lets you translate, scale, rotate, extrude vertices and faces (edit polygons).
"Sculpt mode" lets you push and pull groups of faces (smoosh polygons like clay).
"Vertex paint" lets you apply colors to polygon vertices.

Blender starts you out with a cube. To model anything with this, we need more polygons. Press F9 to get to the Editing panel, and then hit "Add Multires" and then hit "Add Level" six times. Zoom into the now-smoothed high-poly sphere with control-middle-click. Switch to "Sculpt Mode". Hit the "Sculpt" tab to get sculpting options. Turn on symmetry about the X axis. Use the "Add", "Grab", and "Smooth" tools to sculpt the object into something meaningful, like a potato. Save the original as a .blend file. To save a low-poly triangle version in a nice ASCII format, "Apply Multires", "Add Modifier" "Decimate", and set the decimation ratio to 0.1 or so. Hit Apply, and File->Export as a RAW or Wavefront .obj file.

Exporting from 3D modelers to "Real Code"

So 3D modeling programs make it pretty easy to generate cool polygon geometry. The trick is then you've got to somehow move that geometry into your application (game, visualization app, etc).

The easiest way to do this is skip it entirely--just do all your modeling and rendering inside the 3D modeling program! But the modeling performance of these programs usually isn't that good, and you often need to add some simulation or visualization features that would be easy in C++, but tricky in the 3D program.

The standard way to exchange data between programs is of course files. We've looked at several very simple file formats, like the OBJ file format, but modeling programs usually support more than the very simplest "just the polygons" formats, because the modeling programs support way more than just polygons--they have colors, textures, "instanced" sub-pieces (like function calls), and transforms.

Blender supports a bunch of decent file formats:

Blender internal format, extension ".blend". A Blender-proprietary binary file format.
RAW triangles, which really are just "X Y Z X Y Z X Y Z \n". Very simple to read, but the triangles aren't even indexed, so the files are huge. Plus, there's no way to add normals or texture coordinates.
Wavefront .obj format, which consists of vertex lines starting with "v X Y Z", vertex texture coordinates like "vt S T", vertex normals "vn X Y Z", and faces, which list the 1-based index of their vertices. Faces can be either triangles (three vertices) or quads (four vertices). Face lines either have the simple format "f I J K" (I J and K are a 1-based vertex index), or with texture coordinates "f I/TI J/TJ K/TK" (TI TJ and TK are a vertex texture coordinate index), or finally if you included normals each face has separate normals, like "f I//NI J//NJ K//NK" (NI NJ and NK are vertex normal index). For example, here's a two-triangle OBJ file: the vertices are numbered 1-4, and then used by the two faces.
```
# written by foolib v3.7
v 0.0 0.0 0.0
v 0.0 0.1 0.0
v 0.1 0.1 0.0
v 0.1 0.0 0.0
f 1 2 3
f 2 3 4
    
```
VRML 1.0, extension ".wrl". It's all ASCII, but with a strange XML-like nested structure. VMRL can represent object instances and transforms.

Videoscape format, extension ".obj". This format came from the 1980's Amiga program "Videoscape 3D". This is NOT the same as the OBJ format we've been using, but it is a very simple ASCII format:

"3DG1"
<number of vertices>
List of vertices:
	<x y z coordinates for each vertex>
List of faces:
	<number of vertices for this face> <1-based vertex numbers...> <face RGB color, in hex>

Example 3-vertex, 1-face file:
3DG1
3
0.0 0.1 0.0
0.1 0.0 0.0
0.0 0.0 0.1
3 1 2 3 0xff0000

STL (binary) format, extension ".stl". This format is used by 3D printers to generate hardcopy models. This is a binary file format, but it's pretty simple: it's an 80-byte header, followed by one little-endian 32-bit triangle count, followed by a set of "triangle records". Each triangle record has 12 floats: an XYZ normal (sometimes all-zeros) and three XYZ vertices in little-endian 32-bit IEEE floating-point, followed by two zero bytes.
DXF (ascii) format, extension ".dxf". This is AutoCad's "Drawing eXchange Format", but it also supports 3D models (barely!). It's basically a long series of AutoCad commands, and so isn't very easy to read.

To export a fully-rigged model, preserving all the animation and bone info, takes an industrial-strength file format (the 3D analog of a complicated image file format like JPEG!). There's a new XML-based standard called COLLADA that attempts to be that format, but it looks pretty complicated, and it's evolving very quickly.

Generating Tetrahedral Meshes

Virtually all 3D model formats export only the object's surface, but to simulate interesting stuff you usually need some representation of the interior volume. There's a cool package called "TetGen" that can read a *closed* .off or .ply model from Blender and generate interior tetrahedrons. If your model isn't closed, MeshLab can automatically close the holes.

Reading tetrahedra is much like reading triangles: there's a set of 3D vertices, then 4 vertex indices per tet. Next week, we'll look at how to simulate physics on tetrahedral slivers of solid objects!