Game Development Reference
In-Depth Information
mesh using even fewer bytes. Suppose we scan a mesh and do some
analysis. When scanning the mesh we look for two things: the bounding
volume and the shortest edge. As an example, suppose that after such a
scan we find that the bounding volume is (0.835, 1.824, 0.234) >>
(-0.835, 0.000, -0.35) and the shortest edge is 0.002. If we use a 2-byte
integer value we can store 65 536 different values. Will this number of
values give sufficient accuracy to display the mesh without destroying the
overall look? The answer in most cases is yes. Given that the maximum
dimension of the bounding box is less than 2, if we represent 2 using
65 536 then we can represent 1 using 32 768. The maximum accuracy we
can therefore achieve is 1/32 768, approximately 0.00003. If we think of a
value of 1 as being 1 metre in world space, then we can resolve the
accuracy to 3/100 mm. For a real-time game that is more than enough
accuracy. Generally, you will find that a 2-byte integer will give enough
accuracy to display objects in the 3D environment. To use this method
effectively you will need a scaling factor that compares the stored integer
values with actual values in world coordinate space. In this example,
every value must be divided by 32 768 to give a close approximation to
the original vertex values. Therefore, the compression strategy would be
to precede each point list with a scaling value stored as a 4-byte floating-
point value. Since we save 2 bytes every vertex, this means that with a
point list containing just three values we have already experienced some
compression and as the point list increases in number the compression
gets nearer to 50 per cent over floats and 25 per cent over doubles. With
a real world example of around 5000 vertices per scene across six
scenes, Table 18.1 gives an approximation to the bytes needed to store
the point list.
Table 18.1 Point list compression
using doubles, floats and shorts
Two-byte integers
The next list to consider is the polygon list. We allow three- and four-
sided polygons. A polygon contains either three or four indices into the
point list that must be byte accurate or the mesh will be deformed, plus a
polygon needs to know what surface it is using to define its appearance.
If we were content that the vertex list would not exceed 255, then we could
use 1 byte to define the vertex index. This is not likely and future proofing
Search Nedrilad ::

Custom Search