d3d表面中的颜色键问题？请高手帮帮忙？

阿飞

#include <windows.h>
#include <d3d9.h>
#include <d3dx9.h>
#include <string>

#define SPRITE_WIDTH 64
#define SPRITE_HEIGHT 64
#define SCRN_WIDTH 640
#define SCRN_HEIGHT 480

#pragma comment(lib,"d3d9.lib")
#pragma comment(lib,"d3dx9.lib")
#pragma comment(lib,"winmm.lib")

HINSTANCE        hInst;
HWND                hWnd;
char *appName="Direct3DSprite";
char *mes="HELLO WORLD";
                RECT src;
                RECT dest;

LPDIRECT3D9 m_pD3D;
LPDIRECT3DDEVICE9 m_pDevice;
IDirect3DSurface9* m_pSurface;
IDirect3DSurface9* m_pSurface1;

ID3DXSprite *sprite1;
ID3DXSprite *sprite2;
IDirect3DTexture9 *tex1;
IDirect3DTexture9 *tex2;

void GameLoop();
LRESULT CALLBACK WndProc(HWND,UINT,WPARAM,LPARAM);

BOOL InitD3D(HWND hWnd,LPDIRECT3D9 &pD3D,LPDIRECT3DDEVICE9 &pDevice);
BOOL initSurface();
BOOL initSprite1(LPDIRECT3DDEVICE9 &pDevice);
IDirect3DSurface9*        getSurfaceFromBitmap(std::string filename,D3DCOLOR ColorKey);

IDirect3DTexture9* getTextureFromFile(LPDIRECT3DDEVICE9 &pDevice,std::string filename,D3DCOLOR ColorKey);

void Render(LPDIRECT3DDEVICE9 &pDevice);
bool initSprite();
void moveSprite();
void CleanUp();

struct tagSprite{
        RECT sourceRect;
        int X;
        int Y;
        int moveX;
        int moveY;
}spriteStruct[10];

int WINAPI WinMain(HINSTANCE hInstance,HINSTANCE hPrevInstance,
                                   LPTSTR lpCmdLine,int nCmdShow)
{
        WNDCLASSEX wcex={sizeof(WNDCLASSEX),CS_CLASSDC,
                                        WndProc,0L,0L,
                                        GetModuleHandle(NULL),
                                        LoadIcon(NULL,IDI_APPLICATION),NULL,NULL,NULL,
                                        appName,NULL};

        RegisterClassEx(&wcex);

        hWnd=CreateWindow(appName,appName,
                                        WS_OVERLAPPEDWINDOW,
                                        0,0,640,480,
                                        GetDesktopWindow(),NULL,
                                        wcex.hInstance,NULL);


        if(SUCCEEDED(InitD3D(hWnd,m_pD3D,m_pDevice)))
        {
                ShowWindow(hWnd,SW_SHOWNORMAL);
                UpdateWindow(hWnd);
                GameLoop();
        }
        else
        {
                MessageBox(NULL,"Initialise Application Failed!","Failed!",MB_OK);
        }

        UnregisterClass(appName,wcex.hInstance);

        CleanUp();

        return 0;
}

void GameLoop()
{
        MSG msg;
        BOOL fMessage;

        /*static DWORD s_dwOldTime = 0;
        DWORD dwNewTime = timeGetTime();
        if( dwNewTime - s_dwOldTime < 40 )
        {
                return;
        }*/

        PeekMessage(&msg,NULL,0U,0U,PM_NOREMOVE);

        while(msg.message!=WM_QUIT)
        {
                fMessage=PeekMessage(&msg,NULL,0U,0U,PM_REMOVE);
                if(fMessage)
                {
                        TranslateMessage(&msg);
                        DispatchMessage(&msg);
                }
                else
                {
                        Render(m_pDevice);

                }
        }
}

LRESULT CALLBACK WndProc(HWND hWnd,UINT message,WPARAM wParam,LPARAM lParam)
{
        switch(message)
        {
        case WM_DESTROY:
                PostQuitMessage(0);
                break;
        case WM_KEYDOWN:
                switch(wParam)
                {
                case VK_ESCAPE:
                        DestroyWindow(hWnd);
                        break;
                }
        }
        return DefWindowProc(hWnd,message,wParam,lParam);
}

BOOL InitD3D(HWND hWnd,LPDIRECT3D9 &pD3D,
                         LPDIRECT3DDEVICE9 &pDevice)
{
        pD3D=Direct3DCreate9(D3D_SDK_VERSION);

        D3DDISPLAYMODE d3ddm;
        D3DPRESENT_PARAMETERS d3dpp;
       
        pD3D->GetAdapterDisplayMode(D3DADAPTER_DEFAULT,&d3ddm);

        ZeroMemory(&d3dpp,sizeof(d3dpp));

        //Windowed
        d3dpp.Windowed=TRUE;
        d3dpp.SwapEffect=D3DSWAPEFFECT_DISCARD;
        d3dpp.BackBufferFormat=d3ddm.Format;
        d3dpp.BackBufferCount=1;
        d3dpp.BackBufferHeight=480;
        d3dpp.BackBufferWidth=640;
        //Fullscreen
        /*d3dpp.Windowed=FALSE;
        d3dpp.hDeviceWindow=hWnd;
        d3dpp.SwapEffect=D3DSWAPEFFECT_DISCARD;
        d3dpp.BackBufferHeight=600;
        d3dpp.BackBufferWidth=800;
        d3dpp.BackBufferFormat=D3DFMT_A8R8G8B8;//d3ddm.Format;*/

        pD3D->CreateDevice(
                D3DADAPTER_DEFAULT,
                D3DDEVTYPE_HAL,
                hWnd,
                D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                &d3dpp,&pDevice);


        //pDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);

        //Set how the texture should be blended (use alpha)
        //pDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
        //pDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);

        initSurface();
        initSprite();
        //initSprite1(pDevice);
        return TRUE;
}

BOOL initSurface()
{
        m_pSurface=getSurfaceFromBitmap("sprites2.bmp",D3DCOLOR_XRGB(0,0,0));
        if(m_pSurface==NULL)
                return FALSE;

        m_pSurface1=getSurfaceFromBitmap("scene.bmp",D3DCOLOR_XRGB(0,0,0));
        if(m_pSurface1==NULL)
                return FALSE;

        return TRUE;
}

BOOL initSprite1(LPDIRECT3DDEVICE9 &pDevice)
{
        D3DXCreateSprite(pDevice,&sprite1);
        tex1=getTextureFromFile(pDevice,"sprites2.bmp",D3DCOLOR_XRGB(0,0,0));
        D3DXCreateSprite(pDevice,&sprite2);
        tex1=getTextureFromFile(pDevice,"scene.bmp",D3DCOLOR_XRGB(255,0,0));
        return TRUE;
}
IDirect3DSurface9*        getSurfaceFromBitmap(std::string filename,D3DCOLOR ColorKey)
{
        HRESULT hResult;
        IDirect3DSurface9* surface=NULL;
        D3DXIMAGE_INFO        imageInfo;

        hResult=D3DXGetImageInfoFromFile(filename.c_str(),&imageInfo);

        if(FAILED(hResult))
                return NULL;
       
        hResult=m_pDevice->CreateOffscreenPlainSurface(imageInfo.Width,
                imageInfo.Height,
                D3DFMT_A8R8G8B8,
                D3DPOOL_DEFAULT,
                &surface,
                NULL);

        if(FAILED(hResult))
                return NULL;

        hResult=D3DXLoadSurfaceFromFile(surface,
                NULL,NULL,
                filename.c_str(),
                NULL,
                D3DX_DEFAULT,
                ColorKey,
                //0,
                &imageInfo);

        if(FAILED(hResult))
                return NULL;

        return surface;
}

IDirect3DTexture9* getTextureFromFile(LPDIRECT3DDEVICE9 &pDevice,std::string filename,D3DCOLOR ColorKey)
{
        HRESULT hResult;
        IDirect3DTexture9* texture=NULL;
        D3DXIMAGE_INFO        imageInfo;

        hResult=D3DXGetImageInfoFromFile(filename.c_str(),&imageInfo);

        if(FAILED(hResult))
                return NULL;

        hResult=pDevice->CreateTexture(imageInfo.Width,imageInfo.Height,
                0,0,D3DFMT_UNKNOWN,D3DPOOL_MANAGED,&texture,NULL);

        if(FAILED(hResult))
                return NULL;

        D3DXCreateTextureFromFileEx(pDevice, filename.c_str(), 0, 0, 0, 0,
                            D3DFMT_UNKNOWN, D3DPOOL_MANAGED, D3DX_DEFAULT,
                            D3DX_DEFAULT, ColorKey, NULL, NULL, &texture);

        if(FAILED(hResult))
                return NULL;

        return texture;
}
bool initSprite()
{
        for(int i=0;i<10;i++)
        {
                spriteStruct.sourceRect.top=0;
                spriteStruct.sourceRect.left=i*SPRITE_WIDTH;
                spriteStruct.sourceRect.right=spriteStruct.sourceRect.left+SPRITE_WIDTH;
                spriteStruct.sourceRect.bottom=SPRITE_HEIGHT;

                spriteStruct.X=rand()%SCRN_WIDTH-SPRITE_WIDTH;
                spriteStruct.Y=rand()%SCRN_HEIGHT-SPRITE_HEIGHT;

                spriteStruct.moveX=5;
                spriteStruct.moveY=5;
        }
        return true;
}

void moveSprite()
{
        for(int i=0;i<10;i++)
        {
                spriteStruct.X+=spriteStruct.moveX;
                if(spriteStruct.X>(SCRN_WIDTH-SPRITE_WIDTH))
                {
                        spriteStruct.moveX*=-1;
                }

                spriteStruct.Y+=spriteStruct.moveY;
                if(spriteStruct.Y>(SCRN_HEIGHT-SPRITE_HEIGHT))
                {
                        spriteStruct.moveY*=-1;
                }

                if(spriteStruct.X<0)
                {
                        spriteStruct.moveX*=-1;
                }

                if(spriteStruct.Y<0)
                {
                        spriteStruct.moveY*=-1;
                }
        }
}

void Render(LPDIRECT3DDEVICE9 &pDevice)
{
        IDirect3DSurface9* backbuffer=NULL;

        pDevice->Clear(0,NULL,
                D3DCLEAR_TARGET,
                D3DCOLOR_XRGB(255,255,255),
                1.0f,0);

        RECT rect;
        rect.top=0;
        rect.left=0;
        rect.right=300;
        rect.bottom=200;

        /*pDevice->BeginScene();
        sprite1->Begin(D3DXSPRITE_ALPHABLEND);
       
        sprite1->Draw(tex1,&rect,
                0,0,D3DCOLOR_XRGB(0,0,0));*/
        pDevice->GetBackBuffer(0,0,
                D3DBACKBUFFER_TYPE_MONO,
                &backbuffer);

        pDevice->StretchRect(m_pSurface1,NULL,
                backbuffer,NULL,D3DTEXF_NONE);
       
        for(int i=0;i<10;i++)
        {       
                src.top=0;
                src.left=0;
                src.right=src.left+SPRITE_WIDTH;
                src.bottom=src.top+SPRITE_HEIGHT;

                dest.left=spriteStruct.X;
                dest.top=spriteStruct.Y;
                dest.right=dest.left+SPRITE_HEIGHT;
                dest.bottom=dest.top+SPRITE_WIDTH;

                OffsetRect(&src,i*64,0);

                pDevice->StretchRect(m_pSurface,&src,backbuffer,&dest,D3DTEXF_NONE);
        }

        moveSprite();

//        sprite1->End();
//        pDevice->EndScene();

        pDevice-&gtresent(NULL,NULL,NULL,NULL);
}

void CleanUp ()
{
        if( m_pDevice != NULL )
                m_pDevice->Release( );
       
        if( m_pD3D != NULL )
                m_pD3D->Release( );
}

程式中使用表面出现问题，精灵（sprite）也无法显示请高手帮忙？

源程序在附件中。

lights

这个问题令人无话可说！打死我也不相信有什么高等的问题，你设个断点看哪里出现了不正常的值，逐句检查执行结果也花不了什么时间，把问题锁定到很小的一段代码再拿来问吧！你这样问问题对自己不负责任，也对别人不负责任！

阿飞

大哥，我就是找不出来呀，才全贴出来给大家看的，而且我是新手，对于DX调试方面还不很通，就请费心帮忙指点一下吧