给pjblog上面移植自己的ubb功能成功

//我写的一个WM上简单的DX类的截取
#include "StdAfx.h"
#include "DXGraphics.h"
#include "MobileDXDemo1.h"

extern CMobileDXDemo1App theApp;

template<typename T1>
void inline StructInit(T1& st1)
{
    ::ZeroMemory(&st1,sizeof(T1));
    st1.dwSize = sizeof(T1);
}

HRESULT CreateDDSurfaceFromBitmap(IDirectDraw* DDraw1, IDirectDrawSurface* & pdds, HBITMAP hbm, int x, int y,
             int dx, int dy)
{
    HDC hdcImage;
    HDC hdc;
    BITMAP bm;
    //DDSURFACEDESC ddsd;
    HRESULT hr;

    if (hbm == NULL )
    {
        //LOGOUT3(4,_T("INVALID para"));
        return E_FAIL;
    }

    //
    // Select bitmap into a memoryDC so we can use it.
    //
    hdcImage = CreateCompatibleDC(NULL);
    if (!hdcImage) {
        OutputDebugString(TEXT("DDHEL: CreateCompatibleDC failed.\n"));
        //LOGOUT3(5,_T("DDHEL: CreateCompatibleDC failed.\n"));
        return E_FAIL;
    }
    SelectObject(hdcImage, hbm);

    //
    // Get size of the bitmap
    //
    GetObject(hbm, sizeof(bm), &bm);
    dx = dx == 0 ? bm.bmWidth : dx;    // Use the passed size, unless zero
    dy = dy == 0 ? bm.bmHeight : dy;


    DDSURFACEDESC ddsd1;
    StructInit(ddsd1);
    ddsd1.dwFlags = DDSD_HEIGHT | DDSD_WIDTH; /*| DDSD_PIXELFORMAT;*/
    ddsd1.dwHeight = dy;
    ddsd1.dwWidth = dx;
    //StructInit((ddsd2.ddpfPixelFormat));
    //ddsd2.ddpfPixelFormat.dwFlags = DDPF_RGB;
    //ddsd2.ddpfPixelFormat.dwRGBBitCount = 24;

    HRESULT hr1 = DDraw1->CreateSurface(&ddsd1,&pdds,NULL);
    if(hr1 != DD_OK)
    {
        //LOGOUT3(hr1,_T("Cannot create surface!"));
        return hr1;
    }

    DDPIXELFORMAT ddpf;

    if (SUCCEEDED(pdds->GetPixelFormat(&ddpf)))
    {
        TCHAR str1[256];
        _stprintf(str1,_T("Pf RGBcount:%d R:%x G:%x B:%x\n"),ddpf.dwRGBBitCount,ddpf.dwRBitMask,ddpf.dwGBitMask,ddpf.dwBBitMask);
        ::OutputDebugString(str1);
    }

    if ((hr = pdds->GetDC(&hdc)) == DD_OK)
    {
        if (!StretchBlt(hdc,
            0, 0,
            ddsd1.dwWidth,
            ddsd1.dwHeight,
            hdcImage,
            x, y,
            dx, dy,
            SRCCOPY)) hr = E_FAIL;
        pdds->ReleaseDC(hdc);
    }
    DeleteDC(hdcImage);
    return hr;
}


CDXGraphics::CDXGraphics(void)
{
    backDC = 0;
}

CDXGraphics::~CDXGraphics(void)
{
}

bool CDXGraphics::Init(int W,int H,HWND Hwnd)
{
    this->scnW = W;
    this->scnH = H;
    this->theHwnd = Hwnd;

    HRESULT hr1 = DirectDrawCreate(NULL, &DDraw1, NULL);
    if(hr1 != DD_OK)
    {
        return false;
    }
    hr1 = DDraw1->SetCooperativeLevel (this->theHwnd,DDSCL_NORMAL );
    if(hr1 !=DD_OK)
    {
        return false;
    }

    ::DDSURFACEDESC ddsd1;
    StructInit(ddsd1);
    ddsd1.dwFlags = DDSD_CAPS ;
    ddsd1.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE ;

    hr1 = DDraw1->CreateSurface (&ddsd1,&DPrim1,NULL);
    if(hr1 != DD_OK)
    {
        return false;
    }

    DDSURFACEDESC ddsd2;
    StructInit(ddsd2);
    ddsd2.dwFlags =  DDSD_HEIGHT | DDSD_WIDTH/* | DDSD_PIXELFORMAT*/ ;
    ddsd2.dwHeight = scnH;
    ddsd2.dwWidth = scnW;
    /*StructInit((ddsd2.ddpfPixelFormat));
    ddsd2.ddpfPixelFormat.dwFlags = DDPF_RGB;
    ddsd2.ddpfPixelFormat.dwRGBBitCount = 24;
    ddsd2.ddpfPixelFormat.dwRBitMask = 0xff0000;
    ddsd2.ddpfPixelFormat.dwGBitMask = 0xff00;
    ddsd2.ddpfPixelFormat.dwBBitMask = 0xff; */


    hr1 = DDraw1->CreateSurface (&ddsd2, &DBack1,NULL);
    if(hr1 != DD_OK)
    {
        return false;
    }

    hr1 = DDraw1->CreateClipper(0,&DBackClipper1,NULL);
    if(hr1 != DD_OK)
    {
        return false;
    }
    HRGN hRgn1= CreateRectRgn(0,0,scnW,scnH);
    BYTE buf[256];
    LPRGNDATA pRgn1 =(LPRGNDATA) buf;
    GetRegionData(hRgn1,sizeof(buf),pRgn1);
    hr1 = DBackClipper1->SetClipList(pRgn1,0);
    DeleteObject(hRgn1);
    if(hr1 != DD_OK)
    {
        return false;
    }
    hr1 = DBack1->SetClipper(DBackClipper1);
    if(hr1 != DD_OK)
    {
        return false;
    }
    
    return true;
}

bool CDXGraphics::Refresh()
{
    RECT Rc1,Rc2;
    GetWindowRect(theHwnd, &Rc1);
    Rc1.right = Rc1.left + scnW;
    Rc1.bottom = Rc1.top + scnH;

    Rc2.left = 0;
    Rc2.top = 0;
    Rc2.right = scnW;
    Rc2.bottom =scnH;

    HRESULT hr1 = DPrim1->Blt( &Rc1,DBack1,&Rc2,DDBLT_WAITNOTBUSY,NULL);
    return (hr1==DD_OK);
}

bool CDXGraphics::Draw(int x,int y,int w,int h,int resId,int srcX,int srcY,bool useColorKey)
{
    RECT rc1,rc2;
    rc1.left = x;
    rc1.top  = y;
    rc1.right= rc1.left + w;
    rc1.bottom=rc1.top + h;

    rc2.left = srcX;
    rc2.top  = srcY;
    rc2.right= rc2.left + w;
    rc2.bottom=rc2.top + h;

    DWORD flag1 = DDBLT_WAITNOTBUSY ;
    if(useColorKey)
    {
        flag1 |= DDBLT_KEYSRC;
    }

    HRESULT hr1 = this->DBack1->Blt(&rc1,this->vDRes1[resId],&rc2,flag1,NULL);
    return (hr1==DD_OK);
}

bool CDXGraphics::DrawRect(int x1, int y1, int w1, int h1, DWORD color1)
{
    RECT rc1;
    rc1.left = x1;
    rc1.top = y1;
    rc1.right = rc1.left + w1;
    rc1.bottom = rc1.top + h1;

    DDPIXELFORMAT ddpf;

    if (FAILED(DBack1->GetPixelFormat(&ddpf)))
    {
        return 1;
    }
    ::DDBLTFX bfx1;
    StructInit(bfx1);
    bfx1.dwFillColor = color1;


    HRESULT hr1 = DBack1->Blt( &rc1,NULL,NULL,DDBLT_COLORFILL ,&bfx1 );

    return (hr1==DD_OK);
}




int CDXGraphics::LoadRes(LPCTSTR FileName,DWORD colorKey )
{
    int id1 = vDRes1.size();
    
    LPDIRECTDRAWSURFACE lpDD;
    HBITMAP hbmp;

    hbmp = LoadBitmap(theApp.m_hInstance,FileName);
    if(hbmp == NULL)
    {
        return -1;
    }

    HRESULT hr1 = CreateDDSurfaceFromBitmap(this->DDraw1,lpDD,hbmp,0,0,0,0);
    if( hr1 != DD_OK)
    {
        return -1;
    }

    if(colorKey!=0xffffffff)
    {
        DDCOLORKEY cKey;
        cKey.dwColorSpaceHighValue = colorKey;
        cKey.dwColorSpaceLowValue  = colorKey;
        hr1 = lpDD->SetColorKey(0,&cKey);
        if(hr1 != DD_OK){return -1;}
    }

    this->vDRes1.push_back(lpDD);

    DeleteObject(hbmp);

    return id1;
}

//个人某自娱自乐作品截取

/**
* 此类用于描述一个Boss的动作，起到控制boss的作用
*/
public abstract class BossAction1 extends TimeLine1
{
    /**是哪个boss的动作*/
    protected Boss1 boss1;
    
    protected static final int cMaxKey=10; //默认的时间轴最大key数量
    
    public Boss1 GetBoss1(){return boss1;}
    public void SetBoss1(Boss1 val1){boss1=val1;}
    
    /**
     * 构造函数
     * @param TimeInc1 时间轴的增量，参见TimeLine1的构造函数
     * @param MaxKeyCount1 最大TimeKey数量，参见TimeLine1的构造函数
     */
    public BossAction1(int TimeInc1,int maxKeyCount)
    {
        super(TimeInc1,maxKeyCount);
        boss1=null;
        sTimeInc1=TimeInc1;
        sTime1=0;
    }
    
    /**
     * 构造函数，使用默认的TimeKey数量
     * @param TimeInc1 时间轴的增量，参见TimeLine1的构造函数
     */
    public BossAction1(int TimeInc1)
    {
        this(TimeInc1,cMaxKey);
    }
    
    /**
     * 构造函数
     * @param theBoss1 描述哪个boss的动作
     * @param TimeInc1 时间轴的增量，参见TimeLine1的构造函数
     * @param MaxKeyCount1 最大TimeKey数量，参见TimeLine1的构造函数
     */
    public BossAction1(Boss1 theBoss1,int TimeInc1,int maxKeyCount)
    {
        this(TimeInc1,maxKeyCount);
        boss1=theBoss1;
    }
    
    /**
     * boss动作的驱动函数，会先调用go()驱动时间轴，然后引发doAction1()
     * @return doAction1()的返回值
     */
    public final int Action1()
    {
        this.Go();
        int bk1=doAction1();
        return bk1;
    }
    
    /**
     * boss的动作控制函数，默认什么都不做。
     * 重载此函数可以提供对boss的实时控制。（以配合时间轴所提供的非实时控制，如Handle1()等）
     * @return 可自定义返回值，默认返回0。
     */
    protected int doAction1(){return 0;};
    
    /**
     * 当前Action的名字
     * @return 名字
     */
    abstract public String GetActionName1();
    
    /**
     * 获得动作剩余的时间
     * @return 时间（毫秒为单位）
     */
    abstract public int GetLastTime1();
    
}

'很久之前写的2D游戏用VB图像绘制模块截取
Public Declare Function SetPixel Lib "gdi32" (ByVal hdc As Long, ByVal x As Long, ByVal y As Long, ByVal crColor As Long) As Long

Public Declare Function CreateCompatibleDC Lib "gdi32" (ByVal hdc As Long) As Long

Public Declare Function SelectObject Lib "gdi32" (ByVal hdc As Long, ByVal hObject As Long) As Long

Public Declare Function DeleteDC Lib "gdi32" (ByVal hdc As Long) As Long

'==========================================================================================

Public Declare Sub CopyMemory Lib "kernel32" Alias "RtlMoveMemory" (Destination As Any, Source As Any, ByVal Length As Long)

Public Declare Function timeGetTime Lib "winmm.dll" () As Long


Public ResPic1() As StdPicture
Public ResPicDC1() As Long
Public ResPicRect1() As Rect
Public ResPicCount1 As Long

Public TargetSurf1 As PictureBox

Function InitGDI1(NewTargetSurf1 As PictureBox, Optional ByVal sWidth1 As Long = -5, Optional sHeight1 As Long = -5)
Set TargetSurf1 = NewTargetSurf1
TargetSurf1.AutoRedraw = True
TargetSurf1.Parent.ScaleMode = 3
TargetSurf1.ScaleMode = 3
If sWidth1 > 0 Then TargetSurf1.Width = sWidth1
If sHeight1 > 0 Then TargetSurf1.Height = sHeight1
End Function

Function InitGDI_Res1(ByVal Count1 As Long)
ResPicCount1 = 5
ReDim ResPic1(ResPicCount1)
ReDim ResPicDC1(ResPicCount1)
ReDim ResPicRect1(ResPicCount1)

End Function


Function LoadBitmap1(ByVal Idx1 As Long, File1 As String)
Set ResPic1(Idx1) = LoadPicture(File1)
ResPicDC1(Idx1) = CreateCompatibleDC(ByVal 0&)
SelectObject ResPicDC1(Idx1), ResPic1(Idx1).Handle
With ResPicRect1(Idx1)
  .Left = 0
  .Top = 0
  .Right = TargetSurf1.ScaleX(ResPic1(Idx1).Width, vbHimetric, vbPixels)
  .Bottom = TargetSurf1.ScaleY(ResPic1(Idx1).Height, vbHimetric, vbPixels)
End With

End Function
Function CopyBitmap1(ByVal Idx1 As Long, Pic1 As Picture)
Set ResPic1(Idx1) = Pic1
ResPicDC1(Idx1) = CreateCompatibleDC(ByVal 0&)
SelectObject ResPicDC1(Idx1), ResPic1(Idx1).Handle
With ResPicRect1(Idx1)
  .Left = 0
  .Top = 0
  .Right = TargetSurf1.ScaleX(ResPic1(Idx1).Width, vbHimetric, vbPixels)
  .Bottom = TargetSurf1.ScaleY(ResPic1(Idx1).Height, vbHimetric, vbPixels)
End With

End Function

Function GDI_Draw1(ByVal x1 As Long, ByVal y1 As Long, ByVal ResIdx1 As Long, SrcRc1 As Rect, Optional dwRop1 As Long = vbSrcCopy) as Long
Dim back1 As Long
back1 = BitBlt(TargetSurf1.hdc, x1, y1, SrcRc1.Right - SrcRc1.Left, SrcRc1.Bottom - SrcRc1.Top, _
             ResPicDC1(ResIdx1), SrcRc1.Left, SrcRc1.Top, dwRop1)
            
If back1 = 0 Then GDI_Draw1=1

End Function