Creating the
Auto Map Class
The auto map class I've
developed for the book will load a cMesh object and compress
it into a flat version of the map. The flattened map is stored in a series of
vertex
buffers. These vertex buffers use only the X-, Y-, and Z-coordinates of each
vertex plus a single diffuse color. This means that auto maps are compact and
easy
to render. This also means that you can use alpha blending to overlay the map on
the screen without covering the crucial gaming action going on.
Each map section has an
associated flag that defines whether it is visible. The class
allows you to enable or disable those visibility flags, and to make sure that
the
player’s hard work is not in vain, save and load those visibility flags.
Enough talk; now check out the
class declaration:
//-------------------------------------------------------------------------------------------
// The sVertex structure is a custom vertex structure than contains only the
3D coordinates.
// This is used to retrieve coordinate information from a mesh's vertex
buffer.
//-------------------------------------------------------------------------------------------
typedef struct sVertex
{
float x, y, z;
} *sVertexPtr;
typedef struct sMapVertex
{
float x, y, z; // coordinate
D3DCOLOR diffuse; // map color
} *sMapVertexPtr;
#define AUTO_MAP_FVF (D3DFVF_XYZ | D3DFVF_DIFFUSE)
/********************************************************************************************/
typedef class cAutoMap
{
private:
long m_num_sections;
bool* m_visible; // visibility of sections
DIRECT3DVERTEXBUFFER9_PTR* m_map_vb; // map vertex buffer array
IDirect3DVertexBuffer9* m_arrow_vb;
D3DVIEWPORT9 m_viewport; // area to draw map
cCamera m_camera;
float m_scale; // scale used to draw map
//////////////////////////////////////////////////////////////////////////////
public:
cAutoMap()
{
m_num_sections = 0;
m_visible = NULL;
m_map_vb = NULL;
m_arrow_vb = NULL;
m_camera.rotate(1.57f, 0.0f, 0.0f); // point camera down
set_viewport(0, 0, 100, 100);
m_scale = 1.0f;
}
~cAutoMap()
{
free();
}
void free()
{
if(m_map_vb)
{
for(long i = 0; i < m_num_sections; i++)
release_com(m_map_vb[i]);
delete[] m_map_vb;
m_map_vb = NULL;
}
m_num_sections = 0;
delete[] m_visible;
m_visible = NULL;
release_com(m_arrow_vb);
}
long get_num_section()
{
return m_num_sections;
}
void set_viewport(long x_pos, long y_pos, long width, long height)
{
// define an area to draw the map
m_viewport.X = x_pos;
m_viewport.Y = y_pos;
m_viewport.Width = width;
m_viewport.Height = height;
m_viewport.MinZ = 0.0f;
m_viewport.MaxZ = 1.0f;
}
void visible_section(long section)
{
// enable a map section's visibility flag
m_visible[section] = true;
}
void invisible_section(long section)
{
// disable a map section's visibility flag
m_visible[section] = false;
}
//////////////////////////////////////////////////////////////////////////////
public:
bool create(pcstr filename, long color);
bool load(pcstr filename);
bool save(pcstr filename);
void render(cCamera* old_camera,
float map_x_pos, float map_y_pos, float map_z_pos,
float num_arrows,
float* arrow_x_pos, float* arrow_z_pos, float* angle);
} *cAutoMapPtr;
sVertex, to access the vertex coordinates from the source meshes. You use the
second vertex structure, sMapVertex, to store the map sections.
Following the vertex structures
are a collage of variables. Notice the number of map sections in use, an array
of vertex
buffers, an array of char variables used to mark sections of the map that are
visible,
a viewport structure, a cCamera, a scaling factor variable, and a pointer vertex
buffer.
You should be comfortable with
everything except the pointer vertex buffer and the
scaling factor. To make things easier on you, a map being loaded is scaled down
to a
workable size. When you render the auto map, you need to specify coordinates
from
the large map scale, but the auto map class will scale them down to fit the
small map.
For example, a map that is
1,024 units in width and depth is scaled down to 256
units in width and depth. In fact, all maps are scaled down to a size of 256 x
256,
regardless of their size in the .X file.
As for the pointer vertex
buffer, I’ve added the capability to display an arrow
pointer that represents each character on the map. The arrow pointer points in
the
direction each character is facing. This vertex buffer simply contains three
points
and is rendered using a red diffuse color.
In addition to the class’s
private variables, you must deal with the functions.