Hi Yanroy:

Just a quick suggestion here. Writing a MFC window that supports DirectX is doable, but the performance is usually poor and you are taking an extra step without benifit from it in your case, where you are simply writing a map editor. You don''t need DirectX (this doesn''t conflict with your game app which uses DirectX), because all you need is a file format that matches the reading method you use in game App, and a method to display the map in CView.

My recommandation is simply writing the map editor in MFC, and draw the bitmaps with CDC since there is no high graphics involved here. Then have all the tiles saved in a Container class. Using basi SDK functions to save the tile informations in text or Hex format. Also it maybe helpful if you include a header block that gives out certain map info. (the Read function will be reusable in gameApp.

In your Game App. you may use the same SDK code to read the map.

The format of your MFC app would be somehow like this:
CDocument: contains the Container class for the map tiles if your map file is not too big. (otherwise you may need to dynamiclly load portion of the map).

CView: this class contains a CPoint object that records the topleft tile that is visible in the view. Then an algorithm to determine which tiles are visible.
in OnDraw funciton, draw those tiles via CDC pointer
You will then need a set of Command message handler and Mouse message handlers to add/remove tiles from the map.

See if it helps. Thanks,
Turtlenet.

Here we go, a short sample on how to handle bitmap with MFC

void CBitmapTestView::OnDraw(CDC* pDC)
{
CBitmapTestDoc* pDoc = GetDocument();
ASSERT_VALID(pDoc);
// TODO: add draw code for native data here

//Block One
int nTileWidth = 16;
int nTileHeight = 16;
int nDisplayWidth = 100;
int nDisplayHeight = 100;

CBitmap bm;
bm.LoadBitmap(IDB_BITMAP1);
//End Block One


CDC memdc;
memdc.CreateCompatibleDC(pDC);
memdc.SelectObject(&bm);

int nTargetX, nTargetY;
int nSrcX, nSrcY;
for (int i = 0; i < 100; i++)
{
nTargetX = (i % 10)*nDisplayWidth;
nTargetY = (i /10) * nDisplayHeight;
nSrcX = rand()%2 * nTileWidth;
nSrcY = rand()%2 * nTileHeight;
pDC->StretchBlt(nTargetX, nTargetY,nDisplayWidth,nDisplayHeight,&memdc,nSrcX, nSrcY,nTileWidth,nTileHeight,SRCCOPY);
}
}

This is just a demonstration on what can be done. IDB_BITMAP is a bitmap file for the tile map. The one I used has only 4 tiles. The for loop draws a map of 10x10 tiles (the tiles are random in this demo)

the code I used inside for loop:
nSrcX = rand()%2 * nTileWidth;
nSrcY = rand()%2 * nTileHeight;
should be replaced by your code to reflect the actual tile need to be drawn on tile (i%10, i/10) so that it won''t be random anymore.


The code I commented in Block one Should go to CView::OnIntialUpdate() to reduce drawing time, and the related variables should be class members.

nTileWidth and nTileHeight are the actual tile size in the bitmap, while nDisplayWidth and nDisplayHeight reflect the size will be displayed. This is why I use StretchBlt, so that you can show the tiles larger than actual size. Otherwise, you can simply use CDC::BitBlt.


To improve performance, you should also override the Erase Background message handler to do nothing.


See if this helps,
Turtlenet

Yanroy: the CBitmapTestView Class is my own derived class from CView. I made a project called BitmapTest so that MFC App Wizard named my view class "CBitmapTestView". You will get a CView derived class too, and it will supply an OnDraw function. Just add the function body there will do. (OnDraw is like a beaten up WM_PAINT message handler from SDK).

A dialog can be nice too, though a dialog does not have a frame to directly support Toolbars and Menubars (Well, it is still posible to add these items to a dialog, but it''s going to be painful). That''s why I would choose SDI/MDI.

Magmai is right that you don''t have to use MFC for SDI/MDI. straight WinSDK will do, and the memory usable is usually better with WinSDK. It requires more coding than MFC though Then if you also need a docking window with all the tile buttons, MFC is much easier to use without re-route all the window messages.

Turtlenet