具體細(xì)節(jié)說明請參考二維圖形的使用。
下載源碼和工程
為了簡化編程，首先定義一些輔助宏和對一些類型進(jìn)行重定義。
#define release_com(x) { if(x) { x->Release(); x = NULL; } }
#define free_memory(x) { free(x); (x) = NULL; }
#define STREQ(a, b) (*(a) == (*b) && strcmp((a), (b)) == 0)
#define err_msg_box(msg) MessageBox(NULL, msg, "Error", MB_OK)
typedef unsigned char uchar;
typedef unsigned long ulong;
typedef unsigned short ushort;
typedef char* char_ptr;
typedef char* pstr;
typedef uchar* uchar_ptr;
typedef long* long_ptr;
typedef float* float_ptr;
typedef const char* pcstr;
TILE類的定義：
/*************************************************************************
PURPOSE:
Interface for 2D tile.
*************************************************************************/
#ifndef _TILE_H_
#define _TILE_H_
#include "core_common.h"
//=========================================================================================
// This class encapsulate 2D graphics tile draw.
//=========================================================================================
typedef class TILE
{
public:
TILE();
~TILE();
// functions to create and free the tile interface
BOOL create(long num_textures);
void free();
// functions to load and free a single texture
BOOL load_texture(long texture_index, pcstr texture_filename,
short tile_width, short tile_height,
D3DCOLOR transparent, D3DFORMAT format);
void free_texture(long texture_index);
// functions to retrieve tile dimensions and number of tiles in a texture
long get_tile_width(long texture_index);
long get_tile_height(long texture_index);
long get_tile_number(long texture_index);
// draw a single tile at specified location
BOOL draw_tile(long texture_index, long tile_index,
long screen_x, long screen_y,
D3DCOLOR color,
float x_scale, float y_scale);
private:
long m_num_textures; // number of textures
TEXTURE_PTR m_textures; // TEXTURE array
long_ptr m_tile_widths; // tile width array
long_ptr m_tile_heights; // tile height array
long_ptr m_tile_columns; // number of tile columns in texture
} *TILE_PTR;
#endif
TILE類的實(shí)現(xiàn)：
/*************************************************************************
PURPOSE:
Implements for 2D graphics tile.
*************************************************************************/
#include "core_common.h"
#include "core_graphics.h"
#include "tile.h"
//----------------------------------------------------------------------------------
// Constructor, zero member data.
//----------------------------------------------------------------------------------
TILE::TILE()
{
memset(this, 0, sizeof(*this));
}
//----------------------------------------------------------------------------------
// Destructor, free allocated resource.
//----------------------------------------------------------------------------------
TILE::~TILE()
{
free();
}
//----------------------------------------------------------------------------------
// Free allocated resource.
//----------------------------------------------------------------------------------
void TILE::free()
{
// free all tetxures
if(m_num_textures)
{
for(short i = 0; i < m_num_textures; i++)
m_textures[i].free();
}
delete[] m_textures;
m_textures = NULL;
// free width, height, and column arrays.
delete[] m_tile_widths;
delete[] m_tile_heights;
delete[] m_tile_columns;
m_tile_widths = m_tile_heights = m_tile_columns = NULL;
m_num_textures = 0;
}
//----------------------------------------------------------------------------------
// Allocate memory.
//----------------------------------------------------------------------------------
BOOL TILE::create(long num_textures)
{
// free in case of existing data
free();
if((m_num_textures = num_textures) == 0)
return FALSE;
// allocate texture objects
if((m_textures = new TEXTURE[m_num_textures]) == NULL)
return FALSE;
// allocate width, height, and column count arrays
m_tile_widths = new long[m_num_textures];
m_tile_heights = new long[m_num_textures];
m_tile_columns = new long[m_num_textures];
return TRUE;
}
//----------------------------------------------------------------------------------
// Load texture from file.
//----------------------------------------------------------------------------------
BOOL TILE::load_texture(long texture_index, pcstr texture_filename,
short tile_width, short tile_height,
D3DCOLOR transparent, D3DFORMAT format)
{
// error checking
if(texture_index >= m_num_textures || m_textures == NULL || texture_filename == NULL)
return FALSE;
// free older texture resource
free_texture(texture_index);
// load the texture
if(! m_textures[texture_index].load(texture_filename, transparent, format))
return FALSE;
// store width value (get width of texture if no tile_width was specified).
if(tile_width == 0)
m_tile_widths[texture_index] = m_textures[texture_index].get_width();
else
m_tile_widths[texture_index] = tile_width;
// store height value (get height of texture if no tile_height was specified).
if(tile_height == 0)
m_tile_heights[texture_index] = m_textures[texture_index].get_height();
else
m_tile_heights[texture_index] = tile_height;
// Calculate how many columns of tiles there are in the texture.
// This is used to speed up calculations when drawing tiles.
m_tile_columns[texture_index] = m_textures[texture_index].get_width() / m_tile_widths[texture_index];
return TRUE;
}
//----------------------------------------------------------------------------------
// Free specified texture.
//----------------------------------------------------------------------------------
void TILE::free_texture(long texture_index)
{
// error checking
if(texture_index >= m_num_textures || m_textures == NULL)
return;
// free a single texture resource
m_textures[texture_index].free();
}
//----------------------------------------------------------------------------------
// Return tile width.
//----------------------------------------------------------------------------------
long TILE::get_tile_width(long texture_index)
{
// error checking
if(texture_index >= m_num_textures || m_tile_widths == NULL)
return 0;
return m_tile_widths[texture_index];
}
//----------------------------------------------------------------------------------
// Return tile height.
//----------------------------------------------------------------------------------
long TILE::get_tile_height(long texture_index)
{
// error checking
if(texture_index >= m_num_textures || m_tile_widths == NULL)
return 0;
return m_tile_heights[texture_index];
}
//----------------------------------------------------------------------------------
// Return number of tiles.
//----------------------------------------------------------------------------------
long TILE::get_tile_number(long texture_index)
{
// error checking
if(texture_index >= m_num_textures || m_textures == NULL ||
m_tile_columns == NULL || m_tile_widths == NULL || m_tile_heights == NULL)
{
return 0;
}
return m_tile_columns[texture_index] * (m_textures[texture_index].get_height() / m_tile_heights[texture_index]);
}
//----------------------------------------------------------------------------------
// Draw tile.
//----------------------------------------------------------------------------------
BOOL TILE::draw_tile(long texture_index, long tile_index,
long screen_x, long screen_y,
D3DCOLOR color,
float x_scale, float y_scale)
{
// error checking
if(m_textures == NULL || texture_index >= m_num_textures)
return FALSE;
// calculate the source tile coordinates from texture
long _src_x = (tile_index % m_tile_columns[texture_index]) * m_tile_widths[texture_index];
long _src_y = (tile_index / m_tile_columns[texture_index]) * m_tile_heights[texture_index];
return m_textures[texture_index].draw(screen_x ,screen_y, _src_x, _src_y,
m_tile_widths[texture_index], m_tile_heights[texture_index], x_scale, y_scale, color);
}
MAP類的定義：
/*************************************************************************
PURPOSE:
Interface for 2D map.
*************************************************************************/
#ifndef _MAP_H_
#define _MAP_H_
#include "core_common.h"
#define MAX_OBJECTS 1024
typedef struct OBJECT_INFO
{
long x_pos, y_pos;
char tile_index;
} *OBJECT_INFO_PTR;
//=========================================================================================
// This class encapsulate 2D map draw.
//=========================================================================================
typedef class MAP
{
public:
MAP();
~MAP();
// function to create and free a map class
BOOL create(long num_layers, long map_column, long map_row);
void free();
// function to set a map's layer data
BOOL set_map_layer_data(long layer_index, char_ptr layer_data);
// function to clear and add an object to list
void clear_object_list();
BOOL add_object(long x_pos, long y_pos, char tile_index);
char_ptr get_ptr(long layer_index); // get pointer to map array
long get_map_column(); // get column of map
long get_map_row(); // get row of map
// assign TILE object to use for drawing map tiles
BOOL use_tile(TILE_PTR tile);
// Render map using specified top-left map coordinates,
// as well as number of columns and rows to draw, plus layer used to draw objects.
BOOL render(long pos_x, long pos_y,
long num_rows, long num_columns,
long object_layer,
D3DCOLOR color,
float scale_x, float scale_y);
private:
long m_map_column; // column of map
long m_map_row; // row of map
long m_per_layer_size; // size of per map
long m_num_layers; // number of layers
char_ptr m_map_info; // array for tile informarion
TILE_PTR m_tile; // pointer to TILE object
long m_num_objects_to_draw; // number of object need to be drawed
OBJECT_INFO m_objects_info[MAX_OBJECTS]; // object information array
} *MAP_PTR;
#endif
MAP類的實(shí)現(xiàn)：
/*************************************************************************
PURPOSE:
Implement for 2D map.
*************************************************************************/
#include "core_common.h"
#include "core_graphics.h"
#include "tile.h"
#include "map.h"
//----------------------------------------------------------------------------------
// Constructor, zero member data.
//----------------------------------------------------------------------------------
MAP::MAP()
{
memset(this, 0, sizeof(*this));
}
//----------------------------------------------------------------------------------
// Destructor, release allocated resources.
//----------------------------------------------------------------------------------
MAP::~MAP()
{
free();
}
//----------------------------------------------------------------------------------
// Release allocated resources.
//----------------------------------------------------------------------------------
void MAP::free()
{
// free map information array
delete[] m_map_info;
m_map_info = NULL;
m_map_column = m_map_row = 0;
m_num_layers = 0;
}
//----------------------------------------------------------------------------------
// Create map object.
//----------------------------------------------------------------------------------
BOOL MAP::create(long num_layers, long map_column, long map_row)
{
// free a prior map
free();
// save number of layers, map column and row.
m_num_layers = num_layers;
m_map_column = map_column;
m_map_row = map_row;
m_per_layer_size = map_column * map_row;
long total_map_size = num_layers * m_per_layer_size;
// allocate map data memory
if((m_map_info = new char[total_map_size]) == NULL)
return FALSE;
// clear it out
ZeroMemory(m_map_info, total_map_size);
// reset number of objexts to draw
m_num_objects_to_draw = 0;
return TRUE;
}
//----------------------------------------------------------------------------------
// Set map data.
//----------------------------------------------------------------------------------
BOOL MAP::set_map_layer_data(long layer_index, char_ptr layer_data)
{
// error checking
if(layer_index >= m_num_layers)
return FALSE;
// copy over data
memcpy(&m_map_info[layer_index * m_per_layer_size], layer_data, m_per_layer_size);
return TRUE;
}
//----------------------------------------------------------------------------------
// Clear object list which need to be drawed.
//----------------------------------------------------------------------------------
void MAP::clear_object_list()
{
m_num_objects_to_draw = 0;
}
//----------------------------------------------------------------------------------
// Add object to object list.
//----------------------------------------------------------------------------------
BOOL MAP::add_object(long x_pos, long y_pos, char tile_index)
{
if(m_num_objects_to_draw < MAX_OBJECTS)
{
m_objects_info[m_num_objects_to_draw].x_pos = x_pos;
m_objects_info[m_num_objects_to_draw].y_pos = y_pos;
m_objects_info[m_num_objects_to_draw].tile_index = tile_index;
m_num_objects_to_draw++;
return TRUE;
}
return FALSE;
}
//----------------------------------------------------------------------------------
// Return pointer to specfied layer map data.
//----------------------------------------------------------------------------------
char_ptr MAP::get_ptr(long layer_index)
{
if(layer_index >= m_num_layers)
return NULL;
return &m_map_info[layer_index * m_per_layer_size];
}
//----------------------------------------------------------------------------------
// Return map columns.
//----------------------------------------------------------------------------------
long MAP::get_map_column()
{
return m_map_column;
}
//----------------------------------------------------------------------------------
// Return map rows.
//----------------------------------------------------------------------------------
long MAP::get_map_row()
{
return m_map_row;
}
//----------------------------------------------------------------------------------
// Set tile to map.
//----------------------------------------------------------------------------------
BOOL MAP::use_tile(TILE_PTR tile)
{
if((m_tile = tile) == NULL)
return FALSE;
return TRUE;
}
//----------------------------------------------------------------------------------
// Render map.
//----------------------------------------------------------------------------------
BOOL MAP::render(long pos_x, long pos_y,
long num_rows, long num_columns,
long object_layer,
D3DCOLOR color,
float scale_x, float scale_y)
{
// error checking
if(m_map_info == NULL || m_tile == NULL)
return FALSE;
long _tile_width = m_tile->get_tile_width(0);
long _tile_height = m_tile->get_tile_height(0);
// calculate smooth scrolling variables
long _map_x = pos_x / _tile_width;
long _map_y = pos_y / _tile_height;
long _off_x = pos_x % _tile_width;
long _off_y = pos_y % _tile_height;
// loop through each layer
for(long _layer = 0; _layer < m_num_layers; _layer++)
{
// get a pointer to the map data
char_ptr _map_ptr = &m_map_info[_layer * m_per_layer_size];
// loop for each row and column
for(long _row = 0; _row <= num_rows; _row++)
{
for(long _column = 0; _column <= num_columns; _column++)
{
// get the tile index to draw
char _tile_index = _map_ptr[(_row + _map_y) * m_map_column + _column + _map_x];
long _screen_x = _column * _tile_width - _off_x;
long _screen_y = _row * _tile_height - _off_y;
// draw tile
m_tile->draw_tile(0, _tile_index, (DWORD)_screen_x, (DWORD)_screen_y, color, scale_x, scale_y);
}
}
// draw objects if on object _layer
if(_layer == object_layer)
{
for(long i = 0; i < m_num_objects_to_draw; i++)
{
m_tile->draw_tile(0, m_objects_info[i].tile_index,
m_objects_info[i].x_pos - _off_x, m_objects_info[i].y_pos - _off_y,
color, scale_x, scale_y);
}
}
}
return TRUE;
}
測試代碼1，展示了縮放2D貼片的用法。
/*****************************************************************************
PURPOSE:
Test for class TILE and MAP.
*****************************************************************************/
#include "core_common.h"
#include "core_framework.h"
#include "core_graphics.h"
#include "tile.h"
#include "map.h"
#pragma warning(disable : 4996)
class APP : public FRAMEWORK
{
public:
BOOL init()
{
if(! create_display(g_hwnd, get_client_width(g_hwnd), get_client_height(g_hwnd), 16, TRUE, FALSE))
return FALSE;
// create and load the tile set
if(! m_tile.create(1))
return FALSE;
if(! m_tile.load_texture(0, "tiles.bmp", 64, 64, TRUE, D3DFMT_A1R5G5B5))
{
err_msg_box("load texture failed.");
return FALSE;
}
// create and set the map
char _map_data[3][3] = {
{ 0, 1, 0 },
{ 2, 2, 2 },
{ 1, 2, 3 }
};
m_map.create(1, 3, 3);
m_map.set_map_layer_data(0, (char*) &_map_data);
m_map.use_tile(&m_tile);
return TRUE;
}
BOOL APP::frame()
{
// calculate elapsed time
static DWORD _s_last_time = timeGetTime();
DWORD _now_time = timeGetTime();
DWORD _elapsed_time = _now_time - _s_last_time;
// frame lock to 30ms per frame
if(_elapsed_time < 30)
return TRUE;
_s_last_time = _now_time;
if(SUCCEEDED(g_d3d_device->BeginScene()))
{
if(SUCCEEDED(g_d3d_sprite->Begin(0)))
{
D3DCOLOR _color;
static uchar _s_red = 0, _s_green = 0, _s_blue = 0;
static BOOL _s_increment_color = TRUE;
if(_s_increment_color)
{
_color = D3DCOLOR_RGBA(_s_red++, _s_green++, _s_blue++, 255);
if(_s_red >= 255)
_s_increment_color = FALSE;
}
else
{
_color = D3DCOLOR_RGBA(_s_red--, _s_green--, _s_blue--, 255);
if(_s_red <= 0)
_s_increment_color = TRUE;
}
// draw the map
m_map.render(0, 0, 3, 3, 0, _color, 2.0f, 2.0f);
g_d3d_sprite->End();
}
g_d3d_device->EndScene();
present_display();
}
return TRUE;
}
BOOL shutdown()
{
return TRUE;
}
private:
TILE m_tile;
MAP m_map;
};
int PASCAL WinMain(HINSTANCE inst, HINSTANCE, LPSTR cmd_line, int cmd_show)
{
DWORD _window_width = 384;
DWORD _window_height = 384;
DWORD _x_pos = (get_screen_width() - _window_width) / 2;
DWORD _y_pos = (get_screen_height() - _window_height) / 4;
if(! build_window(inst, "tile_class", "tile test", WS_BORDER | WS_CAPTION | WS_MINIMIZEBOX | WS_SYSMENU,
_x_pos, _y_pos, _window_width, _window_height))
{
return -1;
}
APP app;
app.run();
return 0;
}
測試代碼2，展示了平滑卷軸技術(shù)的使用。
/*****************************************************************************
PURPOSE:
Test for class TILE and MAP.
*****************************************************************************/
#include "core_common.h"
#include "core_framework.h"
#include "core_graphics.h"
#include "tile.h"
#include "map.h"
#pragma warning(disable : 4996)
#define TILE_WIDTH 64
#define TILE_HEIGHT 64
#define MAP_COLUMNS 16
#define MAP_ROWS 16
#define TOTAL_MAP_SIZE 1024
class APP : public FRAMEWORK
{
public:
BOOL init()
{
long client_width = get_client_width(g_hwnd);
long client_height = get_client_height(g_hwnd);
m_num_columns_to_draw = client_width / TILE_WIDTH + 1;
m_num_rows_to_draw = client_height / TILE_HEIGHT + 1;
m_max_move_width = TOTAL_MAP_SIZE - client_width;
m_max_move_height = TOTAL_MAP_SIZE - client_height;
if(! create_display(g_hwnd, get_client_width(g_hwnd), get_client_height(g_hwnd), 16, TRUE, FALSE))
return FALSE;
// create and load the tile set
if(! m_tile.create(1))
return FALSE;
if(! m_tile.load_texture(0, "tiles.bmp", TILE_WIDTH, TILE_HEIGHT, TRUE, D3DFMT_A1R5G5B5))
{
err_msg_box("load texture failed.");
return FALSE;
}
// create and set the map
char _map_data[MAP_ROWS][MAP_COLUMNS] = {
{ 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0 },
{ 1, 2, 2, 1, 2, 2, 0, 2, 2, 2, 2, 2, 2, 2, 2, 0 },
{ 2, 2, 2, 2, 2, 2, 0, 2, 2, 2, 2, 2, 2, 0, 2, 0 },
{ 2, 2, 2, 2, 2, 0, 0, 2, 2, 2, 2, 0, 0, 0, 2, 0 },
{ 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0 },
{ 3, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0 },
{ 3, 0, 0, 0, 0, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 0 },
{ 3, 0, 2, 2, 2, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 0 },
{ 0, 0, 2, 2, 2, 0, 0, 2, 2, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 2, 2, 1, 1, 0, 0, 2, 2, 0, 0, 2, 2, 2, 2, 0 },
{ 0, 1, 2, 2, 2, 0, 0, 2, 2, 0, 0, 2, 1, 1, 2, 0 },
{ 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0 },
{ 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 0 },
{ 0, 0, 2, 2, 2, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 },
{ 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }
};
m_map.create(1, MAP_COLUMNS, MAP_ROWS);
m_map.set_map_layer_data(0, (char*) &_map_data);
m_map.use_tile(&m_tile);
return TRUE;
}
BOOL APP::frame()
{
static long _s_x_pos = 0, _s_y_pos = 0;
// calculate elapsed time
static DWORD _s_last_time = timeGetTime();
DWORD _now_time = timeGetTime();
DWORD _elapsed_time = _now_time - _s_last_time;
// frame lock to 33ms per frame
if(_elapsed_time < 33)
return TRUE;
_s_last_time = _now_time;
if(SUCCEEDED(g_d3d_device->BeginScene()))
{
if(SUCCEEDED(g_d3d_sprite->Begin(0)))
{
// draw the map
m_map.render(_s_x_pos, _s_y_pos, m_num_rows_to_draw, m_num_columns_to_draw, 0, 0xFFFFFFFF, 1.0f, 1.0f);
// press arrows to scroll map around
if(GetAsyncKeyState(VK_LEFT)) _s_x_pos -= 8;
if(GetAsyncKeyState(VK_RIGHT)) _s_x_pos += 8;
if(GetAsyncKeyState(VK_UP)) _s_y_pos -= 8;
if(GetAsyncKeyState(VK_DOWN)) _s_y_pos += 8;
// bounds check map coordinates
if(_s_x_pos < 0)
_s_x_pos = 0;
if(_s_x_pos > m_max_move_width)
_s_x_pos = m_max_move_width;
if(_s_y_pos < 0)
_s_y_pos = 0;
if(_s_y_pos > m_max_move_height)
_s_y_pos = m_max_move_height;
g_d3d_sprite->End();
}
g_d3d_device->EndScene();
present_display();
}
return TRUE;
}
BOOL shutdown()
{
return TRUE;
}
private:
TILE m_tile;
MAP m_map;
long m_num_columns_to_draw;
long m_num_rows_to_draw;
long m_max_move_width;
long m_max_move_height;
};
int PASCAL WinMain(HINSTANCE inst, HINSTANCE, LPSTR cmd_line, int cmd_show)
{
DWORD _window_width = 640;
DWORD _window_height = 480;
DWORD _x_pos = (get_screen_width() - _window_width) / 2;
DWORD _y_pos = (get_screen_height() - _window_height) / 4;
if(! build_window(inst, "map_class", "map test", WS_BORDER | WS_CAPTION | WS_MINIMIZEBOX | WS_SYSMENU,
_x_pos, _y_pos, _window_width, _window_height))
{
return -1;
}
APP app;
app.run();
return 0;
}