int DDraw_Draw_Surface_Scaled(LPDIRECTDRAWSURFACE7 source, // source surface to draw
                      int x, int y,                 // position to draw at
                      int width_src, int height_src,// size of source surface
                      int width_dest, int height_dest,// size of dest surface
                      LPDIRECTDRAWSURFACE7 dest,    // surface to draw the surface on
                      int transparent = 1)          // transparency flag
{
// draw the surface at the x,y defined by dest, send both the original
// source size of surface, along with the desired size, if they are 
// different then directdraw will scale the bitmap for you
// note that we are sending
// the size of the surface, we could query for it, but that takes time
// basically, we are really lacking datastructure as this point, since
// you would create a datastructure that keep important info about the
// surface, so you did't have to query it from directdraw


RECT dest_rect,   // the destination rectangle
     source_rect; // the source rectangle                             

// fill in the destination rect
dest_rect.left   = x;
dest_rect.top    = y;
dest_rect.right  = x+width_dest-1;
dest_rect.bottom = y+height_dest-1;

// fill in the source rect
source_rect.left    = 0;
source_rect.top     = 0;
source_rect.right   = width_src-1;
source_rect.bottom  = height_src-1;

// test transparency flag

if (transparent)
   {
   // enable color key blit
   // blt to destination surface
   if (FAILED(dest->Blt(&dest_rect, source,
                     &source_rect,(DDBLT_WAIT | DDBLT_KEYSRC),
                     NULL)))
           return(0);

   } // end if
else
   {
   // perform blit without color key
   // blt to destination surface
   if (FAILED(dest->Blt(&dest_rect, source,
                     &source_rect,(DDBLT_WAIT),
                     NULL)))
           return(0);

   } // end if

// return success
return(1);

} // end DDraw_Draw_Surface_Scaled
Esempio n. 2
0
int DDraw_Draw_Surface(LPDIRECTDRAWSURFACE7 source, // source surface to draw
                      int x, int y,                 // position to draw at
                      int width, int height,        // size of source surface
                      LPDIRECTDRAWSURFACE7 dest,    // surface to draw the surface on
                      int transparent = 1)          // transparency flag
{
	// draw a bob at the x,y defined in the BOB
	// on the destination surface defined in dest

	RECT dest_rect,   // the destination rectangle
		 source_rect; // the source rectangle                             

	// fill in the destination rect
	// 目标表面、也就是需要填充的表面
	dest_rect.left   = x;
	dest_rect.top    = y;
	dest_rect.right  = x+width-1;
	dest_rect.bottom = y+height-1;

	// fill in the source rect
	// 源表面、也就是需要拷贝数据的表面、这里将拷贝的表面
	// 由传递过来的高宽决定
	source_rect.left    = 0;
	source_rect.top     = 0;
	source_rect.right   = width-1;
	source_rect.bottom  = height-1;

	// test transparency flag
	// 设置是否为透明、要就必须设置色彩键
	if (transparent)
	   {
	   // enable color key blit
	   // blt to destination surface
	   if (FAILED(dest->Blt(&dest_rect, source,
						 &source_rect,(DDBLT_WAIT | DDBLT_KEYSRC),
						 NULL)))
			   return(0);

	   } // end if
	else
	   {
	   // perform blit without color key
	   // blt to destination surface
	   if (FAILED(dest->Blt(&dest_rect, source,
						 &source_rect,(DDBLT_WAIT),
						 NULL)))
			   return(0);

	   } // end if

	// return success
	return(1);

} // end DDraw_Draw_Surface
Esempio n. 3
0
void DDDrawBorder()
{
        DDBLTFX ddbltfx;

        if (FScreen.Stretch) return;

        ddbltfx.dwSize=sizeof(ddbltfx);
	ddbltfx.dwFillColor = LetterBoxColour; //RGB(250, 25, 5);

        m_pddsFrontBuffer->Blt(&BorderTop, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &ddbltfx);
        m_pddsFrontBuffer->Blt(&BorderBottom, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &ddbltfx);
        m_pddsFrontBuffer->Blt(&BorderRight, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &ddbltfx);
        m_pddsFrontBuffer->Blt(&BorderLeft, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &ddbltfx);
}
Esempio n. 4
0
void CPage::Blt(LPDIRECTDRAWSURFACE7 lpSurf)
{
	if (childwindow)
	{
		childwindow->Blt(lpSurf);
		return;
	}
	PreBlt();
	RECT d={0,0,sx,sy};
	RECT s={0,0,w,h};

	lpSurf->Blt(&d,surf,&s,DDBLT_WAIT,NULL);

	{	// Cursor malen
		POINT mp;
		GetCursorPos(&mp);
		if (WindowFromPoint(mp)==hWnd)
		{
			::ScreenToClient(hWnd,&mp);

			lpCursor->SetPos(mp.x,mp.y);
			lpCursor->Draw(lpSurf,sx,sy);
		}
	}
}
Esempio n. 5
0
//-----------------------------------------------------------------------------
// Name: dx_Affiche()
// Desc: Affiche le contenu du buffer à l'écran
//-----------------------------------------------------------------------------
bool dx_Affiche ()
{
    if (PleinEcran)
    {
        ErrDd = SurfacePrimaire->Flip (0, DDFLIP_WAIT);
    }
    else
    {
        RECT tRectSrc;
        RECT tRectDest;
        POINT tPosition = {0,0};

        // Copie de Surface suivant la position de la fenêtre
        ClientToScreen (Fenetre, &tPosition);
        GetClientRect  (Fenetre, &tRectDest);

        if (TailleFenetre)
            SetRect (&tRectSrc, 0, 0, tRectDest.right-tRectDest.left,
                     tRectDest.bottom-tRectDest.top);
        else SetRect (&tRectSrc, 0, 0, ResolutionX, ResolutionY);

        OffsetRect (&tRectDest, tPosition.x, tPosition.y);

        ErrDd = SurfacePrimaire->Blt
                (&tRectDest,SurfaceBack,&tRectSrc,DDBLT_WAIT,NULL);
    }

    return dx_Test ();
};
Esempio n. 6
0
HRESULT STDMETHODCALLTYPE Blt(LPDIRECTDRAWSURFACE7 surface, LPRECT lpDestRect, LPDIRECTDRAWSURFACE7 lpDDSrcSurface, LPRECT lpSrcRect, DWORD dwFlags, LPDDBLTFX lpDDBltFx)
{
    //logOutput << CurrentTimeString() << "Hooked Blt()" << endl;

    EnterCriticalSection(&ddrawMutex);

    ddrawSurfaceBlt.Unhook();
    HRESULT hr = surface->Blt(lpDestRect, lpDDSrcSurface, lpSrcRect, dwFlags, lpDDBltFx);
    ddrawSurfaceBlt.Rehook();

    if (SUCCEEDED(hr))
    {
        if (!g_bUseFlipMethod)
        {
            if (getFrontSurface(surface))
            {
                CaptureDDraw();
            }
        }
    }

    LeaveCriticalSection(&ddrawMutex);

    return hr;
}
int Draw_Rectangle(int x1, int y1, int x2, int y2, int color,
                   LPDIRECTDRAWSURFACE7 lpdds)
{
// this function uses directdraw to draw a filled rectangle

DDBLTFX ddbltfx; // this contains the DDBLTFX structure
RECT fill_area;  // this contains the destination rectangle

// clear out the structure and set the size field 
DD_INIT_STRUCT(ddbltfx);

// set the dwfillcolor field to the desired color
ddbltfx.dwFillColor = color; 

// fill in the destination rectangle data (your data)
fill_area.top    = y1;
fill_area.left   = x1;
fill_area.bottom = y2+1;
fill_area.right  = x2+1;

// ready to blt to surface, in this case blt to primary
lpdds->Blt(&fill_area, // ptr to dest rectangle
           NULL,       // ptr to source surface, NA            
           NULL,       // ptr to source rectangle, NA
           DDBLT_COLORFILL | DDBLT_WAIT | DDBLT_ASYNC,   // fill and wait                   
           &ddbltfx);  // ptr to DDBLTFX structure

// return success
return(1);

} // end Draw_Rectangle
Esempio n. 8
0
//-----------------------------------------------------------------------------
// Name: dx_Efface()
// Desc: Efface le buffer d'affichage
//-----------------------------------------------------------------------------
bool dx_Efface (uint8 Rouge, uint8 Vert, uint8 Bleu)
{
    ZeroMemory (&BlitFX, sizeof(BlitFX));

    BlitFX.dwSize = sizeof (BlitFX);

    BlitFX.dwFillColor = RGB (Rouge,Vert,Bleu);

    SurfaceBack->Blt (NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &BlitFX);

    return dx_Test ();
}
Esempio n. 9
0
//-----------------------------------------------------------------------------
// Name: CopySurface()
// Desc: this function copies one surface to another
//-----------------------------------------------------------------------------   
int CopySurface(LPDIRECTDRAWSURFACE7 lpddsDestSurface, RECT *destRect,LPDIRECTDRAWSURFACE7 lpddsSorSurface, RECT *sorRect)
{// this function flips a surface onto the primary surface
	
	//Blt the frame
	ddReturnVal = lpddsDestSurface->Blt(destRect/*dest rect*/,lpddsSorSurface, //pointer to source surface
									  sorRect, //pointer to the source rectangle
									  DDBLT_WAIT | DDBLT_KEYSRC, NULL/*ddbltfx struct*/);//NULL means entire surface
	if (DDFailedCheck(ddReturnVal, "CopySurface(), Blt failed", cpErrorBuf ))
	{	MessageBox(NULL, cpErrorBuf, "DrawSprite()", MB_ICONEXCLAMATION);   return(0); }
		
	return 1;
}
Esempio n. 10
0
//-----------------------------------------------------------------------------
// Name: dx_SurfaceCopie(...)
// Desc: Copie le contenu d'une surface dans le buffer d'affichage
//-----------------------------------------------------------------------------
bool dx_SurfaceCopie (uint8 pNoSurface, uint16 pPosX, uint16 pPosY)
{
    DDSURFACEDESC2 ddsd;
    ZeroMemory ((void*)&ddsd, sizeof(ddsd));
    ddsd.dwSize = sizeof(ddsd);
    ddsd.dwFlags = DDSD_HEIGHT | DDSD_WIDTH;

    Surfaces[pNoSurface]->GetSurfaceDesc (&ddsd);

    RECT rDest = {pPosX, pPosY, pPosX+ddsd.dwWidth-1, pPosY+ddsd.dwHeight-1};

    return (ErrDd = SurfaceBack->Blt (&rDest, Surfaces[pNoSurface], NULL,
                                      DDBLT_WAIT, NULL)) == DD_OK;
}
Esempio n. 11
0
void CCursor::Draw(LPDIRECTDRAWSURFACE7 lpSurf,const int w,const int h)const
{
//#define STRETCHCURSOR
	if (lpSurface[curframe]==NULL)return;
	if ((CursorPos.x<0)||(CursorPos.y<0)||(CursorPos.x>w)||(CursorPos.y>w))return;

	const int hotspotx=10;
	const int hotspoty=5;

#ifdef STRETCHCURSOR
	const int cw=(width*w)/800;
	const int ch=(height*h)/600;

	RECT s={0,0,width,height};
	RECT d={x,y,x+cw,y+ch};
	if (d.right>w)
	{
		s.right-=((d.right-w)*800)/w;
		d.right=w;
	}
	if (d.bottom>h)
	{
		s.bottom-=((d.bottom-h)*600)/h;
		d.bottom=h;
	}

	lpSurf->Blt(&d,lpSurface[curframe],&s,DDBLT_WAIT|DDBLT_KEYSRC,NULL);
#else
	RECT src={0,0,width,height};
	int mx=CursorPos.x-hotspotx;
	int my=CursorPos.y-hotspoty;

	if (mx<0)
	{
		src.left-=mx;
		mx=0;
	}
	if (my<0)
	{
		src.top-=my;
		my=0;
	}
	if (mx+src.right>w)
		src.right=w-mx;
	if (my+src.bottom>h)
		src.bottom=h-my;

	lpSurf->BltFast(mx,my,lpSurface[curframe],&src,DDBLTFAST_SRCCOLORKEY);
#endif
}
Esempio n. 12
0
//-----------------------------------------------------------------------------
// Name: DrawSprite()
// Desc: Draws a list of sprites to a surface using internal (x,y)
//-----------------------------------------------------------------------------
int CSPRITE::DrawSprite(LPDIRECTDRAWSURFACE7 lpddsSurface)
{
	static RECT destRect;
	//static int j=0;
	//static DWORD start=GetTickCount();
	//static CTIMER timer;
	
	if( (m_iState != SPRITE_STATE_DEAD) && ( m_iAttr == SPRITE_ATTR_LOADED) )
	{
		//Fill in dest rect
		destRect.top = m_iY;
		destRect.left = m_iX;
		destRect.bottom = m_iY + m_iHeight;
		destRect.right = m_iX + m_iWidth;
	
		//Setup the time between frames drawn
		if( m_Timer.Elapsed(m_iTimeBetweenFrames) && (m_ipAnimAttr[m_iCurrentAnimSequence] != SPRITE_ANIM_DONE) ) 
		{
			m_Counter++; m_Timer.StartTimer();//m_StartTime=GetTickCount();

			//Check to see if reached last frame in sequence
			if( m_Counter > m_ipAnimSeqMax[m_iCurrentAnimSequence])
				if(m_ipAnimAttr[m_iCurrentAnimSequence] == SPRITE_ANIM_CONT) //check to see if sprite is supposed to be cont animated
					m_Counter=0;
				else  //animate it once
					if( m_ipAnimAttr[m_iCurrentAnimSequence] == SPRITE_ANIM_ONCE )
					{
						m_Counter = m_ipAnimSeqMax[m_iCurrentAnimSequence];
						m_ipAnimAttr[m_iCurrentAnimSequence] = SPRITE_ANIM_DONE;
					}
		}
	
		//Get the next frame from the anim sequence
		m_iCurrentFrame = m_ipAnimations[m_iCurrentAnimSequence][m_Counter];
	
		//Blt the frame
		ddReturnVal = lpddsSurface->Blt(&destRect/*dest rect*/,m_lpddsImage[m_iCurrentFrame], //pointer to source surface
										  &m_Rect, //pointer to the source rectangle
										  DDBLT_WAIT | DDBLT_KEYSRC, NULL/*ddbltfx struct*/);
		if(ddReturnVal != DD_OK)
			if(ddReturnVal==DDERR_SURFACELOST)
			{	this->RestoreSurface(); lpddsPrimary->Restore();OutputDebugString("Surfacelost DrawSprite()\n"); return(1);	}
			else
				if (DDFailedCheck(ddReturnVal, "DrawSprite(), Blt failed", cpErrorBuf ))
					{	MessageBox(main_window_handle, cpErrorBuf, "DrawSprite()", MB_ICONEXCLAMATION);   return(0); }
	}//End if( (m_iState != SPRITE_STATE_DEAD) && ( m_iAttr == SPRITE_ATTR_LOADED) )
	
	return(1);
}
Esempio n. 13
0
//-----------------------------------------------------------------------------
// Name: Flip()
// Desc: this function flips a surface onto the primary surface
//-----------------------------------------------------------------------------   
int Flip(LPDIRECTDRAWSURFACE7 lpddsSurface, RECT destrect)
{// this function flips a surface onto the primary surface
	
	//Blt the frame
	ddReturnVal = lpddsPrimary->Blt(&destrect/*dest rect*/,lpddsSurface, //pointer to source surface
									  NULL, //pointer to the source rectangle
									  DDBLT_WAIT | DDBLT_KEYSRC, NULL/*ddbltfx struct*/);//NULL means entire surface
	if(ddReturnVal!=DD_OK)
		if(ddReturnVal==DDERR_SURFACELOST)
		{	OutputDebugString("Surfacelost Flip(RECT)\n"); lpddsSurface->Restore(); lpddsPrimary->Restore(); return(1);	}
		else
			if (DDFailedCheck(ddReturnVal, "Flip(lpddsSurface, RECT), Blt failed", cpErrorBuf ))
			{	MessageBox(NULL, cpErrorBuf, "SurfaceFuncs", MB_ICONEXCLAMATION);   return(0); }
		
	return 1;
}
Esempio n. 14
0
BOOL Test_PrivateData (INT* passed, INT* failed)
{
	LPDIRECTDRAWSURFACE7 Surface;
    DWORD size, dummy = 0xBAADF00D;
    GUID guid = { 0 };
    GUID guid2 = { 0x1 };

    if(!CreateSurface(&Surface))
        return FALSE;

    // General test
    TEST(Surface->SetPrivateData(guid, NULL, 0, 0) == DDERR_INVALIDPARAMS);
    TEST(Surface->SetPrivateData(guid, (LPVOID)&dummy, 0, 0) == DDERR_INVALIDPARAMS);
    TEST(Surface->SetPrivateData(guid, (LPVOID)0xdeadbeef, sizeof(DWORD), 0) == DDERR_INVALIDPARAMS);
    TEST(Surface->SetPrivateData(guid, (LPVOID)&dummy, sizeof(DWORD), 0) == DD_OK);

    TEST(Surface->GetPrivateData(guid, NULL, 0) == DDERR_INVALIDPARAMS);
    TEST(Surface->GetPrivateData(guid, &dummy, 0) == DDERR_INVALIDPARAMS);
    size = 0;
    TEST(Surface->GetPrivateData(guid, &dummy, &size) == DDERR_MOREDATA && size == sizeof(DWORD));
    size = 2;
    TEST(Surface->GetPrivateData(guid, NULL, &size) == DDERR_MOREDATA && size == sizeof(DWORD));
    TEST(Surface->GetPrivateData(guid, NULL, &size) == DDERR_INVALIDPARAMS);
    TEST(Surface->GetPrivateData(guid, &dummy, &size) == DD_OK && dummy == 0xBAADF00D);
    TEST(Surface->GetPrivateData(guid2, NULL, 0) == DDERR_NOTFOUND);

    TEST(Surface->FreePrivateData(guid) == DD_OK);
    TEST(Surface->FreePrivateData(guid) == DDERR_NOTFOUND);

    // Test for DDSPD_VOLATILE flag
    TEST(Surface->SetPrivateData(guid, (LPVOID)&dummy, sizeof(DWORD), DDSPD_VOLATILE) == DD_OK);
    size = 0;
    TEST(Surface->GetPrivateData(guid, NULL, &size) == DDERR_MOREDATA && size == sizeof(DWORD));
    TEST(Surface->GetPrivateData(guid, &dummy, &size) == DD_OK && dummy == 0xBAADF00D);

	DDBLTFX	 bltfx;
	bltfx.dwSize = sizeof(DDBLTFX);
	bltfx.dwFillColor = RGB(0, 0, 0);
	if(Surface->Blt(NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &bltfx) != DD_OK)
        printf("ERROR: Failed to draw to surface !");
    TEST(Surface->GetPrivateData(guid, &dummy, &size) == DDERR_EXPIRED);

    // TODO: Test for DDSPD_IUNKNOWNPOINTER (see http://msdn.microsoft.com/archive/default.asp?url=/archive/en-us/ddraw7/directdraw7/ddref_5qyf.asp)

    Surface->Release();
    return TRUE;
}
Esempio n. 15
0
HRESULT GameDisplayLoop(HWND hWnd, PFPImage pImage, LONG destX, LONG destY)
{
	HRESULT hResult;
	DDBLTFX ddBltFx;
	memset(&ddBltFx, 0, sizeof(ddBltFx));
	ddBltFx.dwSize = sizeof(ddBltFx);
	ddBltFx.dwROP = SRCCOPY;

	RECT rcMain = { 0 };
	GetClientRect(hWnd, &rcMain);
	ClientToScreen(hWnd, ((LPPOINT)&rcMain) + 0);
	ClientToScreen(hWnd, ((LPPOINT)&rcMain) + 1);
	//FP_DEBUG_MSG(_T("CLINET RECT: (%d, %d) - (%d, %d)\n"), rcMain.top, rcMain.bottom, rcMain.left, rcMain.right);

	RECT rcBack = { 0 };
	DDSURFACEDESC2 ddsd;
	DDRAW_INIT_STRUCT(ddsd);
	if (FAILED(hResult = lpddsBack->Lock(NULL, &ddsd, DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT, NULL)))
	{
		FP_DEBUG_MSG(_T("Lock Error: 0x%08x\n"), hResult);
		return E_FAIL;
	}
	LPPALETTEENTRY lpPalet = NULL;
	if (FAILED(gameGraphics->ChangePalette(FP_PALETTE_DAY, &lpPalet)))
	{
		return E_FAIL;
	}
	LPBYTE lpPixel = (LPBYTE)ddsd.lpSurface;
	LPBYTE lpData = (LPBYTE)pImage->data;
	LONG n = 0;
	for (LONG i = 0; i < pImage->height; i++)
	{
		n = (i + destY) * ddsd.lPitch + destX * sizeof(PALETTEENTRY);
		for (LONG j = 0; j < pImage->width; j++, n += 4)
		{
			LPBYTE lpPtr = &lpPixel[n];
			*(lpPtr + 0) = lpPalet[lpData[(pImage->height - i - 1) * pImage->width + j]].peRed;
			*(lpPtr + 1) = lpPalet[lpData[(pImage->height - i - 1) * pImage->width + j]].peGreen;
			*(lpPtr + 2) = lpPalet[lpData[(pImage->height - i - 1) * pImage->width + j]].peBlue;
			*(lpPtr + 3) = 0;
		}
	}
	lpddsBack->Unlock(NULL);

	lpddsMain->Blt(&rcMain, lpddsBack, NULL, DDBLT_WAIT, &ddBltFx);
	return S_OK;
}
Esempio n. 16
0
	BOOL jcdd_colorFillSurface(LPDIRECTDRAWSURFACE7 lpdds, INT width, INT height, UINT color)
	{
		if(lpdds == NULL)
		{
			return FALSE;
		}
		RECT destRect = {0, 0, width, height};
		DDBLTFX ddbltfx;
		jcdd_initStruct(&ddbltfx);
		ddbltfx.dwFillColor = color;
		if(FAILED(lpdds->Blt(&destRect, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &ddbltfx)))
		{
			return FALSE;
		}

		return TRUE;
	}
Esempio n. 17
0
	BOOL JCDD_Wrapper::drawBitmapData(INT surfaceID, LPRECT srcRect, LPRECT destRect)
	{
		if(!lpjcdd->containsTheOffscreenSurface(surfaceID))
		{
			return FALSE;
		}

		LPDIRECTDRAWSURFACE7 dest = lpjcdd->getBackBufferSurface();
		LPDIRECTDRAWSURFACE7 src = lpjcdd->getOffscreenSurface(surfaceID)->getSurface();
		DWORD bltFlags = lpjcdd->getUseColorKey() ? DDBLT_WAIT | DDBLT_KEYSRC : DDBLT_WAIT;
		if(FAILED(dest->Blt(destRect, src, srcRect, bltFlags, NULL)))
		{
			return FALSE;
		}

		return TRUE;
	}
Esempio n. 18
0
/**
 * vdraw_ddraw_clear_back_screen(): Clear the back buffer.
 * @return 0 on success; non-zero on error.
 */
int WINAPI vdraw_ddraw_clear_back_screen(void)
{
	if (!lpDD || !lpDDS_Back)
		return -1;
	
	DDSURFACEDESC2 ddsd;
	DDBLTFX ddbltfx;
	
	memset(&ddsd, 0, sizeof(ddsd));
	ddsd.dwSize = sizeof(ddsd);
	
	memset(&ddbltfx, 0, sizeof(ddbltfx));
	ddbltfx.dwSize = sizeof(ddbltfx);
	ddbltfx.dwFillColor = 0;
	
	lpDDS_Back->Blt(NULL, NULL, NULL, DDBLT_WAIT | DDBLT_COLORFILL, &ddbltfx);
	
	return 1;
}
Esempio n. 19
0
int DDraw_Fill_Surface(LPDIRECTDRAWSURFACE7 lpdds,int color)
{
DDBLTFX ddbltfx; // this contains the DDBLTFX structure

// clear out the structure and set the size field 
DDRAW_INIT_STRUCT(ddbltfx);

// set the dwfillcolor field to the desired color
ddbltfx.dwFillColor = color; 

// ready to blt to surface
lpdds->Blt(NULL,       // ptr to dest rectangle
           NULL,       // ptr to source surface, NA            
           NULL,       // ptr to source rectangle, NA
           DDBLT_COLORFILL | DDBLT_WAIT,   // fill and wait                   
           &ddbltfx);  // ptr to DDBLTFX structure

// return success
return(1);
} // end DDraw_Fill_Surface
Esempio n. 20
0
void DDAccurateUpdateDisplay(bool singlestep)
{
        static int framecounter=0;
        HRESULT hRet;
        RECT rDest;

        if (++framecounter > zx81.frameskip || singlestep)
                framecounter=0;
        else
                return;

        DDFrame->Unlock(NULL);

        POINT p = {0, 0};
        if(!Form1->FullScreen) p=Form1->ClientToScreen(p);

        rDest=rcdest;
        rDest.left += p.x;
        rDest.top += p.y;
        rDest.right += p.x;
        rDest.bottom += p.y;

        //if (Form1->FullScreen) DDDrawBorder();
        while(1)
        {
                hRet = m_pddsFrontBuffer->Blt(&rDest, DDFrame, &rcsource, DDBLT_WAIT, NULL);

                if (hRet == DD_OK) break;
                else
                if(hRet == DDERR_SURFACELOST)
                {
                        m_pddsFrontBuffer->Restore();
                        m_pddsFrame->Restore();
                }
                else if(hRet != DDERR_WASSTILLDRAWING) return;
        }


        DDFrame->Lock(NULL, &DDFrameSurface, DDLOCK_WAIT |  DDLOCK_NOSYSLOCK, NULL);
        dest=buffer= (BYTE*)DDFrameSurface.lpSurface;
}
Esempio n. 21
0
//-----------------------------------------------------------------------------
// Name: Flip()
// Desc: this function flips a surface onto the primary surface 
//       primary surface expected to be a normal window (non-fullscreen).
//       flips to client area only
//-----------------------------------------------------------------------------   
int FlipToClient(LPDIRECTDRAWSURFACE7 lpddsSurface)
{// this function flips a surface onto the primary surface
	static RECT temp;

	GetWindowRect(main_window_handle, &temp);
	temp.top +=20;
	temp.left +=4;
	temp.right -=4;
	temp.bottom -=4;
	//Blt the frame
	ddReturnVal = lpddsPrimary->Blt(&temp/*dest rect*/,lpddsSurface, //pointer to source surface
									  NULL, //pointer to the source rectangle
									  DDBLT_WAIT | DDBLT_KEYSRC, NULL/*ddbltfx struct*/);//NULL means entire surface
	if(ddReturnVal!=DD_OK)
		if(ddReturnVal==DDERR_SURFACELOST)
		{	OutputDebugString("Surfacelost FlipToClient()\n"); lpddsSurface->Restore(); lpddsPrimary->Restore(); return(1);	}
		else
			if (DDFailedCheck(ddReturnVal, "FlipToClient(lpddsSurface), Blt failed", cpErrorBuf ))
			{	MessageBox(NULL, cpErrorBuf, "SurfaceFuncs", MB_ICONEXCLAMATION);   return(0); }
		
	return 1;
}
// Draw video to DirectDraw surface.
BOOL CDShow::Draw(LPDIRECTDRAWSURFACE7 lpDDSurface7)
{
	// Return FALSE if media was not open
	if (!m_bMediaOpen) {
		return FALSE;
	}


	// Update media stream. 
	// If it does not return S_OK, we are not playing.
	if (m_pSample->Update(0,NULL,NULL,0)!=S_OK) {
		m_bPlaying=FALSE;

	}
	
	// Now blit video to specified surface and rect.
	// Restore surface if lost.
	if (lpDDSurface7->Blt(NULL,m_pDDSurface7, &m_rSrcRect,DDBLT_WAIT,NULL)==DDERR_SURFACELOST)
		lpDDSurface7->Restore();
	
	// Ok. return TRUE.
	return TRUE;
}
Esempio n. 23
0
int Game_Main(void *parms = NULL, int num_parms = 0)
{
// this is the main loop of the game, do all your processing
// here

DDBLTFX ddbltfx; // the blitter fx structure
static int feeling_counter = 0;   // tracks how we feel :)
static int happy = 1;             // let's start off being happy

// make sure this isn't executed again
if (window_closed)
   return(0);

// for now test if user is hitting ESC and send WM_CLOSE
if (KEYDOWN(VK_ESCAPE))
   {
   PostMessage(main_window_handle,WM_CLOSE,0,0);
   window_closed = 1;
   } // end if

// use the blitter to erase the back buffer
// first initialize the DDBLTFX structure
DDRAW_INIT_STRUCT(ddbltfx);

// now set the color word info to the color we desire
ddbltfx.dwFillColor = 0;

// make the blitter call
if (FAILED(lpddsback->Blt(NULL, // pointer to dest RECT, NULL for whole thing
                          NULL, // pointer to source surface
                          NULL, // pointer to source RECT
                          DDBLT_COLORFILL | DDBLT_WAIT, 
                          // do a color fill and wait if you have to
                          &ddbltfx))) // pointer to DDBLTFX holding info
return(0);

// initialize ddsd
DDRAW_INIT_STRUCT(ddsd);

// lock the back buffer surface
if (FAILED(lpddsback->Lock(NULL,&ddsd,
                              DDLOCK_WAIT | DDLOCK_SURFACEMEMORYPTR,
                              NULL)))
    return(0);


// increment how we feel
if (++feeling_counter > 200)
   {
   feeling_counter = 0; 
   happy = -happy;
   } // end if

// draw all the happy faces
for (int face=0; face < 100; face++)
    {
    // are we happy or sad?
    if (happy==1) // we are happy :)
       Blit_Clipped(happy_faces[face].x, 
                    happy_faces[face].y,
                    8,8,    
                    happy_bitmap, 
                    (UCHAR *)ddsd.lpSurface,
                    ddsd.lPitch);         
     else // we must be sad :(
     Blit_Clipped(happy_faces[face].x, 
                  happy_faces[face].y,
                  8,8,    
                  sad_bitmap, 
                  (UCHAR *)ddsd.lpSurface,
                  ddsd.lPitch);     

    } // end face

// move all happy faces
for (face=0; face < 100; face++)
    {
    // move
    happy_faces[face].x+=happy_faces[face].xv;
    happy_faces[face].y+=happy_faces[face].yv;

    // check for off screen, if so wrap
    if (happy_faces[face].x > SCREEN_WIDTH)
         happy_faces[face].x = -8;
    else
    if (happy_faces[face].x < -8)
        happy_faces[face].x = SCREEN_WIDTH;

    if (happy_faces[face].y > SCREEN_HEIGHT)
         happy_faces[face].y = -8;
    else
    if (happy_faces[face].y < -8)
        happy_faces[face].y = SCREEN_HEIGHT;

    } // end face

// unlock surface
if (FAILED(lpddsback->Unlock(NULL)))
   return(0);

// flip the pages
while (FAILED(lpddsprimary->Flip(NULL, DDFLIP_WAIT)));

// wait a sec
Sleep(30);

// return success or failure or your own return code here
return(1);

} // end Game_Main
Esempio n. 24
0
/**
 * vdraw_ddraw_clear_primary_screen(): Clear the primary screen.
 * @return 0 on success; non-zero on error.
 */
int WINAPI vdraw_ddraw_clear_primary_screen(void)
{
	if (!lpDD || !lpDDS_Primary)
		return -1;
	
	DDSURFACEDESC2 ddsd;
	DDBLTFX ddbltfx;
	RECT rd;
	POINT p;
	
	memset(&ddsd, 0, sizeof(ddsd));
	ddsd.dwSize = sizeof(ddsd);
	
	memset(&ddbltfx, 0, sizeof(ddbltfx));
	ddbltfx.dwSize = sizeof(ddbltfx);
	ddbltfx.dwFillColor = 0; // Black
	
	if (vdraw_get_fullscreen())
	{
		if (Video.VSync_FS)
		{
			lpDDS_Flip->Blt(NULL, NULL, NULL, DDBLT_WAIT | DDBLT_COLORFILL, &ddbltfx);
			lpDDS_Primary->Flip(NULL, DDFLIP_WAIT);
			
			lpDDS_Flip->Blt(NULL, NULL, NULL, DDBLT_WAIT | DDBLT_COLORFILL, &ddbltfx);
			lpDDS_Primary->Flip(NULL, DDFLIP_WAIT);
			
			lpDDS_Flip->Blt(NULL, NULL, NULL, DDBLT_WAIT | DDBLT_COLORFILL, &ddbltfx);
			lpDDS_Primary->Flip(NULL, DDFLIP_WAIT);
		}
		else
		{
			lpDDS_Primary->Blt(NULL, NULL, NULL, DDBLT_WAIT | DDBLT_COLORFILL, &ddbltfx);
		}
	}
	else
	{
		p.x = p.y = 0;
		GetClientRect(gens_window, &rd);
		ClientToScreen(gens_window, &p);
		
		rd.left = p.x;
		rd.top = p.y;
		rd.right += p.x;
		rd.bottom += p.y;
		
		// Clip the destination rectangle to the screen.
		if (rd.bottom > vdraw_rectDisplay.bottom)
			rd.bottom += (vdraw_rectDisplay.bottom - rd.bottom);
		if (rd.top < vdraw_rectDisplay.top)
			rd.top += (vdraw_rectDisplay.top - rd.top);
		if (rd.left < vdraw_rectDisplay.left)
			rd.left += (vdraw_rectDisplay.left - rd.left);
		if (rd.right > vdraw_rectDisplay.right)
			rd.right += (vdraw_rectDisplay.right - rd.right);
		
		if (rd.top < rd.bottom)
			lpDDS_Primary->Blt(&rd, NULL, NULL, DDBLT_WAIT | DDBLT_COLORFILL, &ddbltfx);
	}
	
	return 0;
}
Esempio n. 25
0
/**
 * vdraw_ddraw_flip(): Flip the screen buffer. [Called by vdraw_flip().]
 * @return 0 on success; non-zero on error.
 */
int vdraw_ddraw_flip(void)
{
	if (!lpDD)
		return -1;
	
	HRESULT rval = DD_OK;
	DDSURFACEDESC2 ddsd;
	ddsd.dwSize = sizeof(ddsd);
	RECT RectSrc;
	
	// Calculate the source rectangle.
	vdraw_ddraw_calc_RectSrc(RectSrc);
	
	if (vdraw_get_fullscreen())
	{
		// Fullscreen.
		if (vdraw_ddraw_is_hw_render())
		{
			// Hardware rendering.
			
			// 1x rendering.
			// TODO: Test this with border color stuff.
			// Wine doesn't seem to have a 320x240 fullscreen mode available...
			// TODO: Test this on a system that supports 1x in fullscreen on DirectDraw.
			
			vdraw_ddraw_draw_text(&ddsd, lpDDS_Back, true);
			if (Video.VSync_FS)
			{
				lpDDS_Flip->Blt(&RectDest, lpDDS_Back, &RectSrc, DDBLT_WAIT | DDBLT_ASYNC, NULL);
				lpDDS_Primary->Flip(NULL, DDFLIP_WAIT);
			}
			else
			{
				lpDDS_Primary->Blt(&RectDest, lpDDS_Back, &RectSrc, DDBLT_WAIT | DDBLT_ASYNC, NULL);
				//lpDDS_Primary->Blt(&RectDest, lpDDS_Back, &RectSrc, NULL, NULL);
			}
		}
		else
		{
			// Software rendering.
			LPDIRECTDRAWSURFACE7 curBlit = lpDDS_Blit;
			rval = curBlit->Lock(NULL, &ddsd, DDLOCK_WAIT, NULL);
			
			if (FAILED(rval))
				goto cleanup_flip;
			
			vdraw_rInfo.destScreen = (void*)ddsd.lpSurface;
			vdraw_rInfo.width = 320;
			vdraw_rInfo.height = 240;
			vdraw_rInfo.destPitch = ddsd.lPitch;
			
			if (vdraw_needs_conversion)
			{
				// Color depth conversion is required.
				vdraw_rgb_convert(&vdraw_rInfo);
			}
			else
			{
				// Color conversion is not required.
				vdraw_blitFS(&vdraw_rInfo);
			}
			
			// Draw the text.
			vdraw_ddraw_draw_text(&ddsd, curBlit, false);
			
			curBlit->Unlock(NULL);
			
			if (curBlit == lpDDS_Back) // note: this can happen in windowed fullscreen, or if CORRECT_256_ASPECT_RATIO is defined and the current display mode is 256 pixels across
			{
				if (Video.VSync_FS)
				{
					int vb;
					lpDD->GetVerticalBlankStatus(&vb);
					if (!vb)
						lpDD->WaitForVerticalBlank(DDWAITVB_BLOCKBEGIN, 0);
				}
				
				lpDDS_Primary->Blt(&RectDest, lpDDS_Back, &RectSrc, DDBLT_WAIT | DDBLT_ASYNC, NULL);
			}
			else
			{
				if (Video.VSync_FS)
				{
					lpDDS_Primary->Flip(NULL, DDFLIP_WAIT);
				}
			}
		}
	}
	else
	{
		// Windowed mode.
		if (!vdraw_ddraw_is_hw_render())
		{
			rval = lpDDS_Blit->Lock(NULL, &ddsd, DDLOCK_WAIT, NULL);
			
			if (FAILED(rval))
				goto cleanup_flip;
			
			vdraw_rInfo.destScreen = (void*)ddsd.lpSurface;
			vdraw_rInfo.width = 320;
			vdraw_rInfo.height = 240;
			vdraw_rInfo.destPitch = ddsd.lPitch;
			
			if (vdraw_needs_conversion)
			{
				// Color depth conversion is required.
				vdraw_rgb_convert(&vdraw_rInfo);
			}
			else
			{
				// Color conversion is not required.
				vdraw_blitW(&vdraw_rInfo);
			}
			
			// Draw the text.
			vdraw_ddraw_draw_text(&ddsd, lpDDS_Blit, false);
			
			lpDDS_Blit->Unlock(NULL);
		}
		else
		{
			// Draw the text.
			vdraw_ddraw_draw_text(&ddsd, lpDDS_Blit, true);
		}
		
		if (RectDest.top < RectDest.bottom)
		{
			if (Video.VSync_W)
			{
				int vb;
				lpDD->GetVerticalBlankStatus(&vb);
				if (!vb)
					lpDD->WaitForVerticalBlank(DDWAITVB_BLOCKBEGIN, 0);
			}
			
			// Blit the image.
			rval = lpDDS_Primary->Blt(&RectDest, lpDDS_Back, &RectSrc, DDBLT_WAIT | DDBLT_ASYNC, NULL);
			//rval = lpDDS_Primary->Blt(&RectDest, lpDDS_Back, &RectSrc, NULL, NULL);
		}
	}

cleanup_flip:
	if (rval == DDERR_SURFACELOST)
		rval = vdraw_ddraw_restore_graphics();
	
	return 1;
}
Esempio n. 26
0
////FUNCTIONS//////////////////
//-----------------------------------------------------------------------------
// Name: Main()
// Desc: Whwere all work is done
//-----------------------------------------------------------------------------
bool main()
{
    static SCCOLOR col;
    static UCHAR* back_buf;
    static HDC hDC;
    static int iFrames=0;
    static int x=0;

    col.b = col.r = col.g = 255;

    if(GetKeyStatus(VK_ESCAPE) == true)
        return(0);

    //Clear the surface
    if(!ClrS(lpddsSecondary,wndRect))//can't be within a lock-Unlock block or u can't blt
        return(0);

    //Write text to the Secondary surface remember to Release the DC
    ddReturnVal = lpddsSecondary->GetDC(&hDC);
    if (DDFailedCheck(ddReturnVal, "GetDC() failed", cpErrorBuf ))
    {
        if(ddReturnVal == DDERR_SURFACELOST)
        {
            lpddsSecondary->Restore();
            lpddsSecondary->GetDC(&hDC);
        }
        else
        {
            MessageBox(main_window_handle, cpErrorBuf, "main()", MB_ICONEXCLAMATION);
            return(0);
        }
    }

    static char buffer[1024];
    SetBkColor(hDC,RGB(0,0,0));
    SetBkMode(hDC,OPAQUE);
    sprintf(buffer, "Time elapsed(s)= %d", (int)(gametimer.GetStartElapsedTime()*0.001) );//0.00001666666f
    static DWORD starttime=GetTickCount();
    if( gametimer.Elapsed(starttime,(60/0.001)) )
        sprintf(buffer,"TIME!"," 1 minute");
    SetTextColor(hDC,RGB(255,255,255));
    iFrames++;
    static int FramesPerSec=0;
    FramesPerSec = iFrames/( ((int)(gametimer.GetStartElapsedTime()*0.001)+1) );
    sprintf(buffer, "Frames/s = %d", FramesPerSec);
    TextOut(hDC, 100,100, buffer, strlen(buffer));

    sprintf(buffer, "X= %d", x);
    TextOut(hDC, 100,140, buffer, strlen(buffer));
    ddReturnVal = lpddsSecondary->ReleaseDC(hDC);
    if (DDFailedCheck(ddReturnVal, "ReleaseDC() failed", cpErrorBuf ))
    {
        MessageBox(main_window_handle, cpErrorBuf, "main()", MB_ICONEXCLAMATION);
        return(0);
    }

    //Lock the surface for drawing
    if(!Lock(lpddsSecondary))
        return(0);

    back_buf = (UCHAR*)ddsd.lpSurface;

    //test drawing pixels
    DrawPixel(ddsd,x+200,100,col);
    DrawPixel(ddsd,x+200,101,col);
    DrawPixel(ddsd,x+200,102,col);
    DrawPixel(ddsd,x+200,103,col);
    DrawPixel(ddsd,x+200,104,col);
    DrawPixel(ddsd,x+200,105,col);
    DrawPixel(ddsd,x+200,106,col);
    DrawPixel(ddsd,x+200,107,col);
    DrawPixel(ddsd,x+200,108,col);
    x++;
    if(x>780)
        x=0;

    //test bitmap class
    for (int y=0; y < bitmap1.GetHeight(); y++)
    {
        // copy the line
        memcpy(&back_buf[100+(y+200)*ddsd.lPitch], // dest address
               &bitmap1.GetImageData()[y*bitmap1.GetWidth()*2],   // src address
               bitmap1.GetWidth()*2);                         // bytes to copy
    } // end for y

    //Unlock the surface
    if(!UnLock(lpddsSecondary))
        return(0);

    if(!Lock(Temp))
        return(0);
    back_buf = (UCHAR*)ddsd.lpSurface;
    for (int y=0; y < bitmap2.GetHeight(); y++)
    {
        // copy the line
        memcpy(&back_buf[y*ddsd.lPitch], // dest address
               &bitmap2.GetImageData()[y*bitmap2.GetWidth()*2],   // src address
               bitmap2.GetWidth()*2);                         // bytes to copy
    } // end for y
    if(!UnLock(Temp))
        return(0);
    static RECT temprect= {200,200,520,400};
    static RECT sorc_rect= {0,0,320,200};
    ddReturnVal = lpddsSecondary->Blt(&temprect/*dest rect*/,Temp, //pointer to source surface
                                      &sorc_rect, //pointer to the source rectangle
                                      DDBLT_WAIT | DDBLT_KEYSRC,NULL);
    if (DDFailedCheck(ddReturnVal, "Blt failed", cpErrorBuf ))
    {
        MessageBox(main_window_handle, cpErrorBuf, "Main()", MB_ICONEXCLAMATION);
        return(0);
    }


    static RECT temprect2;
    temprect2.top=200;
    temprect2.left=500;
    temprect2.right=sprite.GetWidth()+500;
    temprect2.bottom=sprite.GetHeight()+200;
    static int i=0;
    ddReturnVal = lpddsSecondary->Blt(&temprect2/*dest rect*/,sprite.GetFrame(i), //pointer to source surface
                                      NULL, //pointer to the source rectangle
                                      DDBLT_WAIT | DDBLT_KEYSRC,NULL/*ddbltfx struct*/);
    if (DDFailedCheck(ddReturnVal, "Blt failed", cpErrorBuf ))
    {
        MessageBox(main_window_handle, cpErrorBuf, "Main()", MB_ICONEXCLAMATION);
        return(0);
    }
    static DWORD start = GetTickCount();
    if(gametimer.Elapsed(start,120))
    {
        i++;
        start = GetTickCount();
    }
    if(i>13)
        i=0;

    static int size=0;
    temprect2.top=500+size;
    temprect2.left=300+size;
    temprect2.bottom=500+myface.GetWidth()+size;
    temprect2.right=300+myface.GetWidth()+size;
    ddReturnVal = lpddsSecondary->Blt(&temprect2/*dest rect*/,myface.GetFrame(0), //pointer to source surface
                                      NULL, //pointer to the source rectangle
                                      DDBLT_WAIT | DDBLT_KEYSRC,NULL/*ddbltfx struct*/);
    if (DDFailedCheck(ddReturnVal, "Blt failed", cpErrorBuf ))
    {
        MessageBox(main_window_handle, cpErrorBuf, "Main()", MB_ICONEXCLAMATION);
        return(0);
    }

    static int what=0;
    what++;
    size= sin(what)+cos(what+5);

    static int j=0;
    static DWORD start2=GetTickCount();
    if(gametimer.Elapsed(start2,50))
    {
        j++;
        start2=GetTickCount();
    }
    if(j>=3)j=0;
    temprect2.top=500;
    temprect2.left=100;
    temprect2.bottom=500+ship.GetHeight();
    temprect2.right=100+ship.GetWidth();
    ddReturnVal = lpddsSecondary->Blt(&temprect2/*dest rect*/,ship.GetFrame(j), //pointer to source surface
                                      NULL, //pointer to the source rectangle
                                      DDBLT_WAIT | DDBLT_KEYSRC,NULL/*ddbltfx struct*/);
    if (DDFailedCheck(ddReturnVal, "Blt failed", cpErrorBuf ))
    {
        MessageBox(main_window_handle, cpErrorBuf, "Main()", MB_ICONEXCLAMATION);
        return(0);
    }

    temprect2.top=400;
    temprect2.left=500;
    temprect2.bottom=400+recttest.GetHeight()+50;
    temprect2.right=500+recttest.GetWidth()+50;

    ddReturnVal = lpddsSecondary->Blt(&temprect2/*dest rect*/,recttest.GetFrame(0), //pointer to source surface
                                      &recttest.GetRect(), //pointer to the source rectangle
                                      DDBLT_WAIT | DDBLT_KEYSRC,NULL/*ddbltfx struct*/);
    if (DDFailedCheck(ddReturnVal, "Blt failed", cpErrorBuf ))
    {
        MessageBox(main_window_handle, cpErrorBuf, "Main()", MB_ICONEXCLAMATION);
        return(0);
    }

    temprect2.top=485;
    temprect2.left=160;
    temprect2.bottom=485+ship2.GetHeight();
    temprect2.right=160+ship2.GetWidth();
    static int k=0;
    static DWORD start3;
    if(gametimer.Elapsed(start3,0))
    {
        k++;
        start3=GetTickCount();
    }
    if(k>=11)k=0;

    ddReturnVal = lpddsSecondary->Blt(&temprect2/*dest rect*/,ship2.GetFrame(0), //pointer to source surface
                                      &ship2.GetRect(), //pointer to the source rectangle
                                      DDBLT_WAIT | DDBLT_KEYSRC,NULL/*ddbltfx struct*/);
    if (DDFailedCheck(ddReturnVal, "Blt failed", cpErrorBuf ))
    {
        MessageBox(main_window_handle, cpErrorBuf, "Main()", MB_ICONEXCLAMATION);
        return(0);
    }

    Flip();

    return(1);
}
Esempio n. 27
0
BOOL CH264Decode::PreviewDraw(H264_DEC_FRAME_S DecodeData)
{
	if (!m_bPreEnable)
	{
		return true;
	}

 	DDSURFACEDESC2 ddsd;
	const HI_U8 *pY = DecodeData.pY;
    const HI_U8 *pU = DecodeData.pU;
    const HI_U8 *pV = DecodeData.pV;
    HI_U32 width    = DecodeData.uWidth;
    HI_U32 height   = DecodeData.uHeight;
    HI_U32 yStride  = DecodeData.uYStride;
    HI_U32 uvStride = DecodeData.uUVStride;
	if (0 == width || 0 == height)
	{
		return true;
	}
	ZeroMemory(&ddsd,sizeof(DDSURFACEDESC2));
	ddsd.dwSize = sizeof(DDSURFACEDESC2);
	HRESULT hr;
	hr = m_pOffscreenSurface->Lock(NULL,&ddsd,DDLOCK_WAIT | DDLOCK_SURFACEMEMORYPTR,NULL);
	if (FAILED(hr))
	{
		m_dwLastError = hr;//GetLastError();
		switch(hr)
		{
		case DDERR_SURFACELOST:
			g_pDirectDraw7->RestoreAllSurfaces();
			break;
		case DDERR_SURFACEBUSY:
			m_pOffscreenSurface->Unlock(NULL);
			break;
		default:
			break;
		}
		return FALSE;
	}
	
	
	PBYTE pDestY = (PBYTE)ddsd.lpSurface;
	PBYTE pDestV = (PBYTE)ddsd.lpSurface + ddsd.lPitch * ddsd.dwHeight;
	PBYTE pDestU = (PBYTE)ddsd.lpSurface + ddsd.lPitch * ddsd.dwHeight*5/4;
	for (HI_U32 i = 0;i<height;i++)
	{
		memcpy(pDestY,pY,yStride);
		pDestY += ddsd.lPitch;
		pY += yStride;
	}
	

	for (i = 0;i<height/2;i++)
	{
		memcpy(pDestU,pU,uvStride);
		pDestU += ddsd.lPitch/2;
		pU += uvStride;
	}

	for (i = 0;i<height/2;i++)
	{
		memcpy(pDestV,pV,uvStride);
		pDestV += ddsd.lPitch/2;
		pV += uvStride;
	}
	hr = m_pOffscreenSurface->Unlock(NULL);

    EnterCriticalSection(&m_csCritial);
	if (m_PlayWnd != NULL)
	{
		RECT rcDsp;
		::GetClientRect( m_PlayWnd,&rcDsp);
		POINT ptTL;
		POINT ptRB;
		ptTL.x = rcDsp.left + 1;
		ptTL.y = rcDsp.top + 1;
		ptRB.x = rcDsp.right - 1;
		ptRB.y = rcDsp.bottom - 1;
		::ClientToScreen( m_PlayWnd,&ptTL);
		::ClientToScreen( m_PlayWnd,&ptRB);
		SetRect(&rcDsp,ptTL.x,ptTL.y,ptRB.x,ptRB.y);
		
		//写OSD

/*		HDC		dcTemp;
 		hr = m_pOSDSurface->GetDC(&dcTemp);
		DDSURFACEDESC2 ddsdOsd = {0};
		ddsdOsd.dwSize = sizeof(ddsdOsd);
		m_pOSDSurface->GetSurfaceDesc(&ddsdOsd);

		HBRUSH BackBrush = CreateSolidBrush(RGB(0,0,0));
		RECT rcOsd;
		SetRect(&rcOsd,0,0,ddsdOsd.dwWidth,ddsdOsd.dwHeight);
		FillRect(dcTemp,&rcOsd,BackBrush);
		DeleteObject(BackBrush);

		EnterCriticalSection(&m_csDcCallback);
 		if (NULL != dccallbackFun)
 		{
 			dccallbackFun(dcTemp,m_nDcChl,lpDcUser);
 		}
		LeaveCriticalSection(&m_csDcCallback);
		m_pOSDSurface->ReleaseDC(dcTemp);

		DDSURFACEDESC2 ddsdFin = {0};
		ddsdFin.dwSize = sizeof(ddsdFin);
		m_pFinSurface->GetSurfaceDesc(&ddsdFin);
		RECT rcFin;
		SetRect(&rcFin,0,0,ddsdFin.dwWidth,ddsdFin.dwHeight);

		hr = m_pFinSurface->Blt(&rcFin,m_pOffscreenSurface,&rcSrc,DDBLT_WAIT,NULL);
		hr = m_pFinSurface->Blt(&rcFin,m_pOSDSurface,NULL,DDBLT_WAIT | DDBLT_KEYSRC,NULL);*/
		RECT rcSrc;
		SetRect(&rcSrc,0,0,width,height);
		EnterCriticalSection(&g_csClipper);
		g_pClipper->SetHWnd(NULL,m_PlayWnd);
		if (::IsWindowVisible(m_PlayWnd))
		{
			g_pPrimarySurface->Blt(&rcDsp,m_pOffscreenSurface,&rcSrc,DDBLT_WAIT,0);	
		}
		LeaveCriticalSection(&g_csClipper);
	}
	 LeaveCriticalSection(&m_csCritial);

	return TRUE;
}
Esempio n. 28
0
int Game_Main(void *parms = NULL, int num_parms = 0)
{
// this is the main loop of the game, do all your processing
// here

// lookup for proper walking sequence
// 动画帧、先播放站立动作、然后是摆左手、然后再恢复站立动作、然后是摆右手
// 如此重复播放
// 声明为静态、所以不会随着Game_Main的调用而重复初始化
static int animation_seq[4] = {0,1,0,2};

int index; // general looping variable


// make sure this isn't executed again
if (window_closed)
   return(0);

// for now test if user is hitting ESC and send WM_CLOSE
if (KEYDOWN(VK_ESCAPE))
   {
   PostMessage(main_window_handle,WM_CLOSE,0,0);
   window_closed = 1;
   } // end if


DDRAW_INIT_STRUCT(ddbltfx);

if(lpddsback->Blt(NULL, lpddsbackground, NULL, DDBLT_WAIT, &ddbltfx)) return 0;


// move objects around
// 这里是移动异形
for (index=0; index < 3; index++)
{
// move each object to the right at its given velocity
// 移动异形向右走
aliens[index].x++; // =aliens[index].velocity;

// 测试异形的位置是否已经到达了右边界已经完全看不着了
// 就把它又扔会左边从头走过来
// 因为x是左上角的坐标、所以x超过了屏幕宽度刚好完全看不见
// 而因为异形图片的人物宽度刚好为80、所以重置到左边时设置为-80
// test if off screen edge, and wrap around
if (aliens[index].x > SCREEN_WIDTH)
   aliens[index].x = - 80;

// animate bot
if (++aliens[index].counter >= (8 - aliens[index].velocity))
    {
    // reset counter
    aliens[index].counter = 0;

    // advance to next frame
	// 如果超过第三帧、则重置为第0帧、这里是由前面的结构所决定的、只有三个动作
	// 由于采用了先自增再比较的办法、所以条件这里current_frame的范围恒为1~4
	// 所谓的第零帧、也就是标准的站立动作、可以从位图图片得知、
    if (++aliens[index].current_frame > 3)
       aliens[index].current_frame = 0;

    } // end if

} // end for index


// draw all the bots
for (index=0; index < 3; index++)
{
/*
原型
int DDraw_Draw_Surface(LPDIRECTDRAWSURFACE7 source, // source surface to draw
					  int x, int y,                 // position to draw at
					  int width, int height,        // size of source surface
					  LPDIRECTDRAWSURFACE7 dest,    // surface to draw the surface on
					  int transparent = 1)          // transparency flag
*/
// draw objects
// 把相应的三个异形的每帧动作拷贝进缓冲表面中
// 其中animation_seq[aliens[index].current_frame]决定了产生哪些动作帧
// 在Game_Main函数就已经有定义了static int animation_seq[4] = {0,1,0,2};
// 这里current_frame的范围就是0~3
DDraw_Draw_Surface(aliens[index].frames[animation_seq[aliens[index].current_frame]], 
                   aliens[index].x, aliens[index].y,
                   72,80,
                   lpddsback);

} // end for index


while(FAILED(lpddsprimary->Flip(NULL, DDFLIP_WAIT)));

// 每秒30帧
Sleep(33);


// do nothing -- look at pretty picture

// return success or failure or your own return code here
return(1);

} // end Game_Main
Esempio n. 29
0
int Game_Main(void *parms = NULL, int num_parms = 0)
{

   DDBLTFX ddbltfx;
   RECT    dest_rect;
   static short   curr_color = 0;
   static short   top = 0;
   static short   left = 0;
      
   if (window_closed)
   {
      return (0);
   }
      // for now test if user is hitting ESC and send WM_CLOSE
   if (KEYDOWN(VK_ESCAPE))
   {
      window_closed = true;
      SendMessage(main_window_handle,WM_CLOSE,0,0);
   }

   
   
   // just blast pixels here..
#if 0
   // this is the main loop of the game, do all your processing
   // here
   memset(&ddsd,0,sizeof(ddsd));
   ddsd.dwSize = sizeof(ddsd);
   
   if (FAILED(lpddsprimary->Lock(NULL,
                                 &ddsd,
                                 DDLOCK_SURFACEMEMORYPTR | DDLOCK_WAIT,
                                 NULL)
             )
      )
   {
      // BAD SHIT HAPPENED HERE...
      g_ddStepFailure = DDSF_LOCKFAILED;
      SendMessage(main_window_handle,WM_CLOSE,0,0);   
   }
   
   int   mempitch       = (ddsd.lPitch >> 1); // adjust for words..
   WORD  *video_buffer  = (WORD *) ddsd.lpSurface;
#endif   
   // prefigure mPitchlookup for even greater speed.
   

   // x1,y1
   dest_rect.left = left;
   dest_rect.top  = top;
   // x2,y2
   dest_rect.right   = dest_rect.left+20;
   dest_rect.bottom  = dest_rect.top+20;

   // setup structure!!!!          
   memset(&ddbltfx,0,sizeof(ddbltfx));
   ddbltfx.dwSize = sizeof(ddbltfx);
   // color to fill.
   ddbltfx.dwFillColor = colors16[curr_color];

   // blit it baby!
   if (FAILED(lpddsprimary->Blt(&dest_rect,
                                NULL,           // no source surface.. its just a fill
                                NULL,           // no source RECT, since no source surface..
                                DDBLT_COLORFILL | DDBLT_WAIT,
                                &ddbltfx                       )))
   {
      return(0);
   }

#if 0
   
   lpddsprimary->Unlock(NULL);
#endif   
   top = top + 10;
   left = left + 10;
   
   if (top > SCREEN_HEIGHT - 20)
   {
      top = 0;
   }
   if (left > SCREEN_WIDTH - 20)
   {
      left = 0;
   }
   
   curr_color++;
   if (curr_color > 5000)
   {
      curr_color = 0;
   }
   
   // return success or failure or your own return code here
   return(1);

} // end Game_Main
Esempio n. 30
0
void CDDrawRecord::DDsfDrawToDDsf(LPDIRECTDRAWSURFACE7 lpDDsfd, RECT& dst, LPDIRECTDRAWSURFACE7 lpDDSfr, RECT& rt)
{
	HRESULT hr = lpDDsfd->Blt(&dst, lpDDSfr, &rt, DDBLT_WAIT, NULL);
}