diff options
author | Paul Gilbert | 2012-05-03 22:49:30 +1000 |
---|---|---|
committer | Paul Gilbert | 2012-05-03 22:49:30 +1000 |
commit | a2982a0b20027f658c9b47266a8ddbec74a15878 (patch) | |
tree | c324455bc893fbc48ffb6b13fa4b153e30b93a7d /engines/tony/window.cpp | |
parent | ba2711b5e39e495c4cfb1187710605bb9fbf10b1 (diff) | |
download | scummvm-rg350-a2982a0b20027f658c9b47266a8ddbec74a15878.tar.gz scummvm-rg350-a2982a0b20027f658c9b47266a8ddbec74a15878.tar.bz2 scummvm-rg350-a2982a0b20027f658c9b47266a8ddbec74a15878.zip |
TONY: Engine is now compiling and linking again
Diffstat (limited to 'engines/tony/window.cpp')
-rw-r--r-- | engines/tony/window.cpp | 1255 |
1 files changed, 1255 insertions, 0 deletions
diff --git a/engines/tony/window.cpp b/engines/tony/window.cpp new file mode 100644 index 0000000000..ab68030b90 --- /dev/null +++ b/engines/tony/window.cpp @@ -0,0 +1,1255 @@ +/* ScummVM - Graphic Adventure Engine + * + * ScummVM is the legal property of its developers, whose names + * are too numerous to list here. Please refer to the COPYRIGHT + * file distributed with this source distribution. + * + * This program is free software; you can redistribute it and/or + * modify it under the terms of the GNU General Public License + * as published by the Free Software Foundation; either version 2 + * of the License, or (at your option) any later version. + + * This program is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + + * You should have received a copy of the GNU General Public License + * along with this program; if not, write to the Free Software + * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. + * + */ +/************************************************************************** + * ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ * + * Nayma Software srl * + * e -= We create much MORE than ALL =- * + * u- z$$$c '. ÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍÍ * + * .d" d$$$$$b "b. * + * .z$* d$$$$$$$L ^*$c. * + * #$$$. $$$$$$$$$ .$$$" Project: Roasted Moths........ * + * ^*$b 4$$$$$$$$$F .d$*" * + * ^$$. 4$$$$$$$$$F .$P" Module: Window.HPP........... * + * *$. '$$$$$$$$$ 4$P 4 * + * J *$ "$$$$$$$" $P r Author: Giovanni Bajo........ * + * z$ '$$$P*4c.*$$$*.z@*R$$$ $. * + * z$" "" #$F^ "" '$c Desc: Classi per la gestione * + * z$$beu .ue=" $ "=e.. .zed$$c di una finestra Direct + * "#$e z$*" . `. ^*Nc e$"" Draw................. * + * "$$". .r" ^4. .^$$" ..................... * + * ^.@*"6L=\ebu^+C$"*b." * + * "**$. "c 4$$$ J" J$P*" OS: [ ] DOS [X] WIN95 [ ] PORT * + * ^"--.^ 9$" .--"" COMP: [ ] WATCOM [X] VISUAL C++ * + * " [ ] EIFFEL [ ] GCC/GXX/DJGPP * + * * + * This source code is Copyright (C) Nayma Software. ALL RIGHTS RESERVED * + * * + **************************************************************************/ + +#include "tony/window.h" +#include "tony/game.h" +#include "tony/tony.h" + +namespace Tony { + +#define DDRELEASE(x) if (x) { (x)->Release(); (x)=NULL; } + +// Tabella per il b&w. Globale per accederci dalla roba ASM +static uint16 m_wPrecalcTable[0x10000]; + +/****************************************************************************\ +* Metodi di RMWindow +\****************************************************************************/ + +#ifdef REFACTOR_ME +LRESULT CALLBACK GlobalWindowProc(HWND hWnd, uint32 msg, uint16 wParam, int32 lParam) { + if ((HWND)theGame.m_wnd == NULL) + return DefWindowProc(hWnd, msg, wParam, lParam); + + switch (msg) { + case WM_CREATE: + return 0; + + case WM_CLOSE: + PostQuitMessage(0); + return 0; + + default: + return theGame.m_wnd.WindowProc(msg, wParam, lParam); + } +} +#endif + +#ifdef REFACTOR_ME +LRESULT RMWindow::WindowProc(uint32 msg, uint16 wParam, int32 lParam) { + switch (msg) { + case WM_ACTIVATE: + if (LOWORD(wParam)!=WA_INACTIVE) + theGame.Pause(false); + else + theGame.Pause(true); + return 0; + + case WM_ENTERMENULOOP: + case WM_ENTERSIZEMOVE: + if (!m_bFullscreen) + theGame.Pause(true); + return 0; + + case WM_EXITMENULOOP: + case WM_EXITSIZEMOVE: + if (!m_bFullscreen) + theGame.Pause(false); + return 0; +/* + case WM_KEYDOWN: + switch (wParam) + { + case '0': + case '1': + case '2': + case '3': + case '4': + case '5': + case '6': + case '7': + case '8': + case '9': + if (GetAsyncKeyState(VK_CONTROL)&0x8000) + theGame.SaveState(wParam-'0'); + else if (GetAsyncKeyState(VK_SHIFT)&0x8000) + theGame.LoadState(wParam-'0'); + return 0; + } + return 0; +*/ + + case WM_PAINT: +// Repaint(); + ValidateRect(m_hWnd, NULL); + return 0; + + case WM_COMMAND: + switch LOWORD(wParam) { +/* + case ID_OPTIONS: + theGame.OptionScreen(); + break; +*/ + + case ID_FULLSCREEN: + theGame.SwitchFullscreen(!m_bFullscreen); + break; +/* + case ID_ENABLEINPUT: + theGame.GetEngine()->EnableInput(); + break; +*/ + case ID_SCREENSHOT: + m_bGrabScreenshot = true; +// m_bGrabMovie = !m_bGrabMovie; + break; + + case ID_MOVIE: +// m_bGrabMovie = !m_bGrabMovie; + break; +/* + case ID_BLACKWHITE: + m_bBlackWhite = !m_bBlackWhite; + break; +*/ + default: + return DefWindowProc(m_hWnd, msg, wParam, lParam); + } + return 0; + + case WM_SYSKEYDOWN: + if (m_bFullscreen) + return 0; + else + return DefWindowProc(m_hWnd ,msg, wParam, lParam); + + default: + if (m_hWnd != NULL) // Fix del bug visto da BoundsChecker + return DefWindowProc(m_hWnd, msg, wParam, lParam); + return 0; + } +} +#endif + +/* +HANDLE hWaitFlip; +bool bExitThread; + +void DoFlipThread(LPDIRECTDRAWSURFACE lpDDSPrimary) +{ + bExitThread=false; + + while (1) + { + WaitForSingleObject(hWaitFlip,INFINITE); + if (bExitThread) _endthread(); + lpDDSPrimary->Flip(NULL,DDFLIP_WAIT); + } +} +*/ + +void RMWindow::InitDirectDraw(void) { +#ifdef REFACTOR_ME + DDInit(); + + ShowCursor(false); + ShowWindow(m_hWnd, SW_SHOW); + UpdateWindow(m_hWnd); +#endif +} + +void RMWindow::Init(/*HINSTANCE hInst*/) { +#ifdef REFACTOR_ME + WNDCLASS wc; + + // Registra la classe di finestra + wc.style = CS_HREDRAW|CS_VREDRAW; + wc.lpfnWndProc = GlobalWindowProc; + wc.cbClsExtra = 0; + wc.cbWndExtra = 0; + wc.hInstance = hInst; + wc.hIcon = LoadIcon(hInst,MAKEINTRESOURCE(IDI_ICON1)); + wc.hCursor = LoadCursor(NULL,IDC_ARROW); + wc.hbrBackground = NULL; + wc.lpszMenuName = NULL; + wc.lpszClassName = "RMClass"; + RegisterClass(&wc); + + m_hWnd = CreateWindow( + "RMClass", + "Tony Tough and the night of Roasted Moths", + WS_OVERLAPPEDWINDOW & (~WS_THICKFRAME) & (~WS_BORDER) & (~WS_MAXIMIZEBOX), + 50, 50, + RM_SX + GetSystemMetrics(SM_CXDLGFRAME) * 2, + RM_SY + GetSystemMetrics(SM_CYDLGFRAME) * 2 + GetSystemMetrics(SM_CYMENU) + GetSystemMetrics(SM_CYCAPTION), + NULL, + NULL, + hInst, + NULL + ); + + if (m_hWnd == NULL) { + int err = GetLastError(); + RMString str; + + str.Format("error: %u",err); + MessageBox(NULL,str,"sux",MB_OK); + + assert(0); + } + + // Inizializza la finestra directdraw + //DDInit(); + + // Inizializza i conteggi degli FPS + fps = lastfcount = fcount = lastsecond = 0; + + m_bGrabScreenshot = false; + m_bGrabThumbnail = false; + m_bGrabMovie = false; + + //hWaitFlip = CreateEvent(NULL,false,false, NULL); +#endif +}; + +void RMWindow::Close(void) { + DDClose(); +#ifdef REFACTOR_ME + DestroyWindow(m_hWnd); +#endif +} + +void RMWindow::GrabThumbnail(uint16 *thumbmem) { + m_bGrabThumbnail = true; + m_wThumbBuf = thumbmem; +} + +float RGB_to_HSL(float r,float g, float b, float *h, float *s, float *l) { + float v; + float m; + float vm; + float r2, g2, b2; + + if (r > g) v = r; else v = g; + if (v > b) v = v; else v = b; + if (r < b) m = r; else m = b; + if (m < b) m = m; else m = b; + + if ((*l = (m + v) / 2.0f) <= 0.0f) return *l; + if ((*s = vm = v - m) > 0.0f) { + *s /= (*l <= 0.5f) ? (v + m) : (2.0f - v - m) ; + } else + return *l; + + r2 = (v - r) / vm; + g2 = (v - g) / vm; + b2 = (v - b) / vm; + + if (r == v) + *h = (g == m ? 5.0f + b2 : 1.0f - g2); + else if (g == v) + *h = (b == m ? 1.0f + r2 : 3.0f - b2); + else + *h = (r == m ? 3.0f + g2 : 5.0f - r2); + + *h /= 6; + + return *l; +} + +#define ITOF(val) (float)((float)(val) / 31.0f) +#define FTOI(val) (int)(((float)(val) * 31.0f + 0.5f)) + +void RMWindow::CreateBWPrecalcTable(void) { +#define CLAMP(var, min, max) var = (var < min ? min : (var > max ? max : var)); + + int i; + int r, g, b; + int min, max; + int shiftR, shiftG, shiftB; + + // Calcola i valori di shift in base alle maschere + for (shiftR = 15; (mskRed & (1 << shiftR)) == 0; shiftR--) + ; + for (shiftG = 15; (mskGreen & (1 << shiftG)) == 0; shiftG--) + ; + for (shiftB = 15; (mskBlue & (1 << shiftB)) == 0; shiftB--) + ; + + shiftR -= 4; + shiftG -= 4; + shiftB -= 4; + + // @@@ CLAMP inutile (in teoria) + CLAMP(shiftR, 0, 15); + CLAMP(shiftG, 0, 15); + CLAMP(shiftB, 0, 15); + + for (i = 0;i<0x10000;i++) + { + r=(i >> shiftR) & 0x1F; + g=(i >> shiftG) & 0x1F; + b=(i >> shiftB) & 0x1F; + +#if 1 + if (r < g) min=r; else min = g; + if (b < min) min = b; + if (r > g) max = r; else max = g; + if (b > max) max = b; + min = (min + max) / 2; +#else + // Nuova formula B&W. L'immagine è più fedele all'originale, ma l'effetto è peggiore + float fr, fg, fb; + + fr = (float)r / 63.0f; + fg = (float)g / 63.0f; + fb = (float)b / 63.0f; + + min = (int)((fr*0.11f + fg*0.69f + fb*0.33f)*63.f); +#endif + + /* + RGB_to_HSL(ITOF(r), ITOF(g), ITOF(b), &h, &s, &l); + min = FTOI(l); + */ + + r = min + 8 - 8; + g = min + 5 - 8; + b = min + 0 - 8; + + CLAMP(r, 0, 31); + CLAMP(g, 0, 31); + CLAMP(b, 0, 31); + + m_wPrecalcTable[i] = (b << shiftB) | (g << shiftG) | (r << shiftR); + } +} + + +void RMWindow::DDClose(void) { +#ifdef REFACTOR_ME + DDRELEASE(m_Back); + DDRELEASE(m_Primary); + DDRELEASE(m_MainClipper); + DDRELEASE(m_BackClipper); + DDRELEASE(m_DD); +#endif +} + +void RMWindow::DDInit(void) { +#ifdef REFACTOR_ME + HRESULT err; + + // Crea DirectDraw + err = DirectDrawCreate(NULL, &m_DD, NULL); + assert(err == DD_OK); + + // Crea il clipper + err = DirectDrawCreateClipper(0, &m_MainClipper, NULL); + err=DirectDrawCreateClipper(0, &m_BackClipper, NULL); + + // Lo associa alla finestra + m_MainClipper->SetHWnd(0, m_hWnd); + + // Setta la cooperazione a normal + m_DD->SetCooperativeLevel(m_hWnd, DDSCL_NORMAL); + +#ifdef STARTFULLSCREEN + // Di default in fullscreen + m_bFullscreen=false; // Fa finta, per obbligarlo a cambiare + m_Primary=m_Back=NULL; + SwitchFullscreen(true); +#else + // Di default in finestra + m_bFullscreen = true; // Fa finta, per obbligarlo a cambiare + m_Primary = m_Back = NULL; + SwitchFullscreen(false); +#endif + +/* + if (!ISMODE1() && !ISMODE2() && !ISMODE3() && !ISMODE4()) + { + RMString str; + str.Format("Graphic mode not supported: %04x %04x %04x",mskRed,mskGreen,mskBlue); + MessageBox(m_hWnd,str,"Debug",MB_OK); + } +*/ +#endif +} + + +void RMWindow::SwitchFullscreen(bool bFull) { +#ifdef REFACTOR_ME + HRESULT err; + DDSURFACEDESC ddsd; + DDSCAPS ddscaps; + DDBLTFX ddbltfx; + Common::Rect rcWin; + + // Se non c'e' niente da fare, esci + if (bFull == m_bFullscreen) + return; + + // Termina il thread di flipping + //bExitThread = true; + + // Rilascia le superfici create in precedenza (se ce n'erano) + DDRELEASE(m_Back); + DDRELEASE(m_Primary); + + // Legge le coordinate della finestra + if (m_bFullscreen) { + rcWin.left = 50; + rcWin.top = 50; + } else { + GetWindowRect(m_hWnd, &rcWin); + } + + if (bFull) { + // Setta la risoluzione + m_DD->SetCooperativeLevel(m_hWnd, DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN | DDSCL_ALLOWREBOOT); + m_DD->SetDisplayMode(RM_SX, RM_SY, 16); + + // A tutto schermo, possiamo creare una catena di flipping + ZeroMemory(&ddsd, sizeof(ddsd)); + ddsd.dwSize = sizeof(ddsd); + ddsd.dwFlags = DDSD_CAPS|DDSD_BACKBUFFERCOUNT; + ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_COMPLEX | DDSCAPS_FLIP; + ddsd.dwBackBufferCount = 1; + if ((err=m_DD->CreateSurface(&ddsd, &m_Primary, NULL)) != DD_OK) { + //wsprintf(errbuf,"Error creating primary surface2 (%lx)",err); + //MessageBox(hWnd,errbuf,"grSwitchFullscreen()",MB_OK); + assert(0); + } + + ddscaps.dwCaps = DDSCAPS_BACKBUFFER; + if ((err=m_Primary->GetAttachedSurface(&ddscaps, &m_Back)) != DD_OK) { + //wsprintf(errbuf,"Error getting attached surface2 (%lx)",err); + //MessageBox(hWnd,errbuf,"grSwitchFullscreen()",MB_OK); + assert(0); + } + + // Pulisce i buffer + ddbltfx.dwSize = sizeof(ddbltfx); + ddbltfx.dwFillColor = 0; + m_Back->Blt(NULL, NULL, NULL,DDBLT_COLORFILL | DDBLT_WAIT, &ddbltfx); + + ddbltfx.dwSize=sizeof(ddbltfx); + ddbltfx.dwFillColor = 0; + m_Primary->Blt(NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &ddbltfx); + + // Inizializza il thread + //_beginthread((void (*)(void*))DoFlipThread,10240,(void*)m_Primary); + } else { + // In windowed, non possiamo fare flipping (purtroppo) + m_DD->RestoreDisplayMode(); + m_DD->SetCooperativeLevel(m_hWnd,DDSCL_NORMAL); + + ZeroMemory(&ddsd,sizeof(ddsd)); + ddsd.dwSize=sizeof(ddsd); + ddsd.dwFlags=DDSD_CAPS; + ddsd.ddsCaps.dwCaps=DDSCAPS_PRIMARYSURFACE; + if ((err=m_DD->CreateSurface(&ddsd,&m_Primary, NULL)) != DD_OK) { + //wsprintf(errbuf,"Error creating primary surface (%lx)",err); + //MessageBox(hWnd,errbuf,"ChangeResolution()",MB_OK); + assert(0); + } + + ZeroMemory(&ddsd,sizeof(ddsd)); + ddsd.dwSize=sizeof(ddsd); + ddsd.dwFlags=DDSD_CAPS|DDSD_WIDTH|DDSD_HEIGHT; + ddsd.ddsCaps.dwCaps=DDSCAPS_OFFSCREENPLAIN; // se puo', in video memory + ddsd.dwWidth=RM_SX; + ddsd.dwHeight=RM_SY; + if ((err=m_DD->CreateSurface(&ddsd,&m_Back, NULL)) != DD_OK) { + //wsprintf(errbuf,"Error creating backbuffer surface (%lx)",err); + //MessageBox(hWnd,errbuf,"ChangeResolution()",MB_OK); + assert(0); + } + + // Pulizia per favore + ddbltfx.dwSize = sizeof(ddbltfx); + ddbltfx.dwFillColor = 0; + m_Back->Blt(NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &ddbltfx); + } + + // Posiziona e ridimensiona la finestra + if (bFull) { + SetWindowPos(m_hWnd, HWND_TOP, 0, 0, RM_SX, RM_SY, 0); + + // Disabilita il clipper (non necessario) + m_Primary->SetClipper(NULL); + } else { + SetWindowPos(m_hWnd, HWND_TOP, rcWin.left, rcWin.top, RM_SX + GetSystemMetrics(SM_CXDLGFRAME) * 2, + RM_SY + GetSystemMetrics(SM_CYDLGFRAME) * 2 + GetSystemMetrics(SM_CYCAPTION), 0); + + m_Primary->SetClipper(m_MainClipper); + //m_Primary->SetClipper(NULL); + } + + // Si ricorda il nuovo stato + m_bFullscreen = bFull; + InvalidateRect(m_hWnd, NULL, false); + + // Legge il nuovo pixel format + UpdatePixelFormat(); +#endif +} + +void RMWindow::UpdatePixelFormat(void) { +#ifdef REFACTOR_ME + DDPIXELFORMAT ddpf; + + // Si fa ridare il nuovo pixel format + ddpf.dwSize = sizeof(ddpf); + m_Primary->GetPixelFormat(&ddpf); + + // Copia le componenti dei colori + mskRed = ddpf.dwRBitMask; + mskGreen = ddpf.dwGBitMask; + mskBlue = ddpf.dwBBitMask; + + // Ricalcola la tabella per l'effetto b&w + CreateBWPrecalcTable(); +#endif +} + + +void RMWindow::Repaint(void) { +#ifdef REFACTOR_ME + Common::Rect rcWin; + HRESULT err; + + if (m_Primary==NULL) + return; + + // Se siamo a tutto schermo, basta un flip + if (m_bFullscreen) { + m_DD->WaitForVerticalBlank(DDWAITVB_BLOCKBEGIN, NULL); + + // Flippa flappa + while (1) { + //err=m_Primary->Flip(NULL,DDFLIP_WAIT); + err = m_Primary->BltFast(0, 0, m_Back, NULL, DDBLTFAST_WAIT); + + if (err==DD_OK) + break; + else if (err == DDERR_SURFACELOST) { + //MessageBox(NULL,"Primary lost!","RMWindow::Repaint()",MB_OK); + m_Primary->Restore(); + return; + } + } + } + // Altrimenti bisogna andare di blit + else { + // Si calcola il rettangolo effettivamente visibile + GetWindowRect(m_hWnd, &rcWin); + OffsetRect(&rcWin, GetSystemMetrics(SM_CXDLGFRAME), GetSystemMetrics(SM_CYDLGFRAME) + GetSystemMetrics(SM_CYCAPTION)); + + // Aggiusta le dimensioni del rettangolo + rcWin.right = rcWin.left + RM_SX; + rcWin.bottom = rcWin.top + RM_SY; + + // Blit del back nel primary + while (1) { + err = m_Primary->Blt(&rcWin, m_Back, NULL,DDBLT_WAIT, NULL); + if (err == DD_OK) + break; + else if (err == DDERR_SURFACELOST) { + //MessageBox(NULL,"Primary lost!","RMWindow::Repaint()",MB_OK); + m_Primary->Restore(); + return; + } + } + } +#endif +} + + +void RMWindow::Unlock(DDSURFACEDESC &ddsd) { +#ifdef REFACTOR_ME + m_Back->Unlock(ddsd.lpSurface); +#endif +} + +void RMWindow::WipeEffect(Common::Rect &rcBoundEllipse) { +#ifdef REFACTOR_ME + Common::Rect rcScreen; + HRGN hrgnCombined; + HRGN hrgnScreen; + HRGN hrgnEllipse; + uint32 dwDataSize; + RGNDATA *rgnData; + + SetRect(&rcScreen, 0, 0, 640, 480); + + hrgnScreen = CreateRectRgnIndirect(&rcScreen); + hrgnEllipse = CreateEllipticRgnIndirect(&rcBoundEllipse); + hrgnCombined = CreateRectRgnIndirect(&rcScreen); + + CombineRgn(hrgnCombined, hrgnScreen, hrgnEllipse, RGN_DIFF); + + dwDataSize = GetRegionData(hrgnCombined, 0, NULL); + rgnData = (RGNDATA *)new char[dwDataSize]; + GetRegionData(hrgnCombined, dwDataSize, rgnData); + + m_BackClipper->SetClipList(rgnData, 0); + m_Back->SetClipper(m_BackClipper); + + DDBLTFX ddbltfx; + ddbltfx.dwSize=sizeof(ddbltfx); + ddbltfx.dwFillColor = 0; + m_Back->Blt(NULL, NULL, NULL, DDBLT_COLORFILL | DDBLT_WAIT, &ddbltfx); + + m_Back->SetClipper(NULL); + delete [] rgnData; + DeleteObject(hrgnCombined); + DeleteObject(hrgnEllipse); + DeleteObject(hrgnScreen); +#endif +} + +bool RMWindow::Lock(DDSURFACEDESC &ddsd) { +#ifdef REFACTOR_ME + HRESULT err; + + // Lock della surface + ddsd.dwSize = sizeof(ddsd); + while (1) { + err = m_Back->Lock(NULL,&ddsd,DDLOCK_WAIT|DDLOCK_WRITEONLY|DDLOCK_NOSYSLOCK, NULL); + if (err==DD_OK) + break; + else if (err==DDERR_SURFACELOST) { +// MessageBox(NULL,"Primary lost!","RMWindow::Repaint()",MB_OK); + m_Back->Restore(); + return false; + } + } +#endif + return true; +} + +void RMWindow::GetNewFrame(byte *lpBuf, Common::Rect *rcBoundEllipse) { +#ifdef REFACTOR_ME + HRESULT err; + DDSURFACEDESC ddsd; + int x,y; + byte *dest; + uint16 *destw; + RMString s; + uint16 *src,src2; + + if (GetAsyncKeyState(VK_F7)&0x8001) + goto DOFRAMERATE; + + if (!Lock(ddsd)) + return; + + // Copia del buffer + src = (uint16 *)lpBuf; + dest = (byte *)ddsd.lpSurface; +// src+=RM_SKIPY*RM_BBX; Lo skipY e' integrato nell'offseting del bigbuffer + + if (ISMODE2()) { + // 565 RGB, Marco - Matrox G200 + int lineinc = (ddsd.lPitch / 2 - RM_SX) * 2; + int lineinc2 = (RM_BBX - RM_SKIPX - RM_SX) * 2; + destw = (uint16 *)dest; + + if (bCfgAnni30) { + __asm { + pushad + + mov y,RM_SY + mov esi,src + mov edi,dest + + //ALIGN 4 + line30: + mov x,RM_SX + add esi,RM_SKIPX*2 + + line302: + mov eax,[esi] ; U 1 + mov ebx,[esi+4] ; V + mov ecx,eax ; U 2 + mov edx,ebx ; V + and eax,0x7FE07FE0 ; U 3 + and ebx,0x7FE07FE0 ; V + and ecx,0x001F001F ; U 4 + and edx,0x001F001F ; V + shl eax,1 ; U 5 + shl ebx,1 ; V + or eax,ecx ; U 6 + or ebx,edx ; V + + // Codice B&W - Pairato + mov ecx,eax + mov edx,ebx + and eax,0xFFFF + and ebx,0xFFFF + shr ecx,16 + shr edx,16 + mov eax,[offset m_wPrecalcTable + eax*2] + mov ebx,[offset m_wPrecalcTable + ebx*2] + mov ecx,[offset m_wPrecalcTable + ecx*2] + mov edx,[offset m_wPrecalcTable + edx*2] + shl ecx,16 + shl edx,16 + and eax,0xFFFF + and ebx,0xFFFF + or eax,ecx + or ebx,edx + + mov [edi],eax ; U 7 + mov [edi+4],ebx ; V + add esi,8 ; U 8 + add edi,8 ; V + sub x,4 ; U 9 + jnz line302 ; V + + add esi,lineinc2 + add edi,lineinc + + dec y + jnz line30 + + popad + } + + } else { + __asm { + pushad + + mov y,RM_SY + mov esi,src + mov edi,dest + + //ALIGN 4 + line: + mov x,RM_SX + add esi,RM_SKIPX*2 + + line2: + mov eax,[esi] ; U 1 + mov ebx,[esi+4] ; V + mov ecx,eax ; U 2 + mov edx,ebx ; V + and eax,0x7FE07FE0 ; U 3 + and ebx,0x7FE07FE0 ; V + and ecx,0x001F001F ; U 4 + and edx,0x001F001F ; V + shl eax,1 ; U 5 + shl ebx,1 ; V + or eax,ecx ; U 6 + or ebx,edx ; V + mov [edi],eax ; U 7 + mov [edi+4],ebx ; V + add esi,8 ; U 8 + add edi,8 ; V + sub x,4 ; U 9 + jnz line2 ; V + + add esi,lineinc2 + add edi,lineinc + + dec y + jnz line + + popad + } + } + } else if (ISMODE3()) { + // 5551 RGB + int lineinc = (ddsd.lPitch / 2 - RM_SX) * 2; + int lineinc2 = (RM_BBX - RM_SKIPX - RM_SX) * 2; + destw=(uint16 *)dest; + + if (bCfgAnni30) { + __asm { + mov y,RM_SY + mov esi,src + mov edi,dest + + aline30: + mov x,RM_SX + add esi,RM_SKIPX*2 + + aline302: + mov eax,[esi] ; U 1 + mov ebx,[esi+4] ; V + shl eax,1 ; U 2 + shl ebx,1 ; V + + // Codice B&W - Pairato + mov ecx,eax + mov edx,ebx + and eax,0xFFFF + and ebx,0xFFFF + shr ecx,16 + shr edx,16 + mov eax,[offset m_wPrecalcTable + eax*2] + mov ebx,[offset m_wPrecalcTable + ebx*2] + mov ecx,[offset m_wPrecalcTable + ecx*2] + mov edx,[offset m_wPrecalcTable + edx*2] + shl ecx,16 + shl edx,16 + and eax,0xFFFF + and ebx,0xFFFF + or eax,ecx + or ebx,edx + + mov [edi],eax ; U 3 + mov [edi+4],ebx ; V + add esi,8 ; U 4 + add edi,8 ; V + sub x,4 ; U 5 + jnz aline302 ; V + + add esi,lineinc2 + add edi,lineinc + + dec y + jnz aline30 + } + } else { + __asm { + mov y,RM_SY + mov esi,src + mov edi,dest + + aline: + mov x,RM_SX + add esi,RM_SKIPX*2 + + aline2: + mov eax,[esi] ; U 1 + mov ebx,[esi+4] ; V + shl eax,1 ; U 2 + shl ebx,1 ; V + mov [edi],eax ; U 3 + mov [edi+4],ebx ; V + add esi,8 ; U 4 + add edi,8 ; V + sub x,4 ; U 5 + jnz aline2 ; V + + add esi,lineinc2 + add edi,lineinc + + dec y + jnz aline + } + } + } else if (ISMODE4()) { + // 565 BGR - Intergraph + int lineinc=(ddsd.lPitch / 2 - RM_SX) * 2; + int lineinc2=(RM_BBX - RM_SKIPX - RM_SX) * 2; + destw=(uint16 *)dest; + + if (bCfgAnni30) // Manca supporto per Intergraph ... non so pairarlo!!! :) + { + __asm { + mov y,RM_SY + mov esi,src + mov edi,dest + + //ALIGN 4 + intersux30: + mov ecx,RM_SX + add esi,RM_SKIPX*2 + + intersux302: + mov eax,[esi] ; U 1 0BBBBBGGGGGRRRRR 0BBBBBGGGGGRRRRR + add esi,4 ; V + mov ebx,eax ; U 2 0BBBBBGGGGGRRRRR 0BBBBBGGGGGRRRRR + mov edx,eax ; V 0BBBBBGGGGGRRRRR 0BBBBBGGGGGRRRRR + shl eax,11 ; U 3 RRRRR0BBBBBGGGGG RRRRR00000000000 + and ebx,0x03E003E0 ; V 000000GGGGG00000 000000GGGGG00000 + and edx,0x7C007C00 ; U 4 0BBBBB0000000000 0BBBBB0000000000 + and eax,0xF800F800 ; V RRRRR00000000000 RRRRR00000000000 + shr edx,10 ; U 5 00000000000BBBBB 00000000000BBBBB + add ebx,ebx ; V 00000GGGGG000000 00000GGGGG000000 + or eax,edx ; U 6 RRRRR000000BBBBB RRRRR000000BBBBB + add edi,4 ; V + or eax,ebx ; U 7 RRRRRGGGGG0BBBBB RRRRRGGGGG0BBBBB + sub ecx,2 ; V + mov [edi-4],eax ; U 8 + jnz intersux302 ; V + + add esi,lineinc2 + add edi,lineinc + + dec y + jnz intersux30 + } + } else { + __asm { + mov y,RM_SY + mov esi,src + mov edi,dest + + //ALIGN 4 + intersux: + mov ecx,RM_SX + add esi,RM_SKIPX*2 + + intersux2: + mov eax,[esi] ; U 1 0BBBBBGGGGGRRRRR 0BBBBBGGGGGRRRRR + add esi,4 ; V + mov ebx,eax ; U 2 0BBBBBGGGGGRRRRR 0BBBBBGGGGGRRRRR + mov edx,eax ; V 0BBBBBGGGGGRRRRR 0BBBBBGGGGGRRRRR + shl eax,11 ; U 3 RRRRR0BBBBBGGGGG RRRRR00000000000 + and ebx,0x03E003E0 ; V 000000GGGGG00000 000000GGGGG00000 + and edx,0x7C007C00 ; U 4 0BBBBB0000000000 0BBBBB0000000000 + and eax,0xF800F800 ; V RRRRR00000000000 RRRRR00000000000 + shr edx,10 ; U 5 00000000000BBBBB 00000000000BBBBB + add ebx,ebx ; V 00000GGGGG000000 00000GGGGG000000 + or eax,edx ; U 6 RRRRR000000BBBBB RRRRR000000BBBBB + add edi,4 ; V + or eax,ebx ; U 7 RRRRRGGGGG0BBBBB RRRRRGGGGG0BBBBB + sub ecx,2 ; V + mov [edi-4],eax ; U 8 + jnz intersux2 ; V + + add esi,lineinc2 + add edi,lineinc + + dec y + jnz intersux + } + } + } else { + // 555 RGB - Computer di Bagio, nVidia Riva 128 + int lineinc = (ddsd.lPitch / 2 - RM_SX) * 2; + int lineinc2 = (RM_BBX - RM_SKIPX - RM_SX) * 2; + destw=(uint16 *)dest; + + if (bCfgAnni30) { + __asm { + mov y,RM_SY + mov esi,src + mov edi,dest + + bagioline30: + mov x,RM_SX + add esi,RM_SKIPX*2 + + bagioline302: + mov eax,[esi] ; U 1 + mov ebx,[esi+4] ; V + + // Codice B&W - Pairato + mov ecx,eax + mov edx,ebx + and eax,0xFFFF + and ebx,0xFFFF + shr ecx,16 + shr edx,16 + mov eax,[offset m_wPrecalcTable + eax*2] + mov ebx,[offset m_wPrecalcTable + ebx*2] + mov ecx,[offset m_wPrecalcTable + ecx*2] + mov edx,[offset m_wPrecalcTable + edx*2] + shl ecx,16 + shl edx,16 + and eax,0xFFFF + and ebx,0xFFFF + or eax,ecx + or ebx,edx + + mov [edi],eax ; U 3 + mov [edi+4],ebx ; V + add esi,8 ; U 4 + add edi,8 ; V + sub x,4 ; U 5 + jnz bagioline302 ; V + + add esi,lineinc2 + add edi,lineinc + + dec y + jnz bagioline30 + } + } else { + for (y = 0; y < RM_SY; y++) { + CopyMemory(dest, src + RM_SKIPX, RM_SX * 2); + dest += ddsd.lPitch; + src += RM_BBX; + } + } + } + + + // Unlock + Unlock(ddsd); + + // Effetto di wipe + if (rcBoundEllipse) { + WipeEffect(*rcBoundEllipse); + } + + // Repaint + Repaint(); + +DOFRAMERATE: + + // Conteggio per gli FPS + fcount++; + + if (lastsecond + 1000 < _vm->GetTime()) { + lastsecond = _vm->GetTime(); + fps=fcount - lastfcount; + lastfcount = fcount; + + if (!m_bFullscreen) { + s.Format("Tony Tough and the night of Roasted Moths - %u FPS",fps); + SetWindowText(m_hWnd,s); + } + } if (!_vm->getIsDemo()) { + if (m_bGrabScreenshot || m_bGrabMovie) { + RMSnapshot snapshot; + + snapshot.GrabScreenshot(lpBuf); + m_bGrabScreenshot = false; + } + + if (m_bGrabThumbnail) { + RMSnapshot snapshot; + + snapshot.GrabScreenshot(lpBuf, 4, m_wThumbBuf); + m_bGrabThumbnail = false; + } + } +#endif +} + + +/****************************************************************************\ +* Metodi di RMSnapshot +\****************************************************************************/ + +char RMSnapshot::bufDrive[_MAX_DRIVE]; +char RMSnapshot::bufDir[_MAX_DIR]; +char RMSnapshot::bufName[_MAX_FNAME]; +char RMSnapshot::bufExt[_MAX_EXT]; +char RMSnapshot::filename[512]; +byte RMSnapshot::rgb[RM_SX * RM_SY * 3]; + +bool RMSnapshot::GetFreeSnapName(char *fn) { +#ifdef REFACTOR_ME + int i, j, k; + HANDLE h; + + theGame.GetDataDirectory(RMGame::DD_SHOTS, fn); + _splitpath(fn, bufDrive, bufDir, NULL, NULL); + + for (i = 1; i < 10; i++) { + wsprintf(bufName,"rm%d00",i); + _makepath(fn,bufDrive,bufDir,bufName,".bmp"); + h = CreateFile(fn,GENERIC_READ,FILE_SHARE_READ, NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL, NULL); + if (h == INVALID_HANDLE_VALUE) + break; + CloseHandle(h); + } + + i--; + + for (j = 1; j < 10; j++) { + wsprintf(bufName,"rm%d%d0",i,j); + _makepath(fn,bufDrive,bufDir,bufName,".bmp"); + h=CreateFile(fn,GENERIC_READ,FILE_SHARE_READ, NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL, NULL); + if (h==INVALID_HANDLE_VALUE) + break; + CloseHandle(h); + } + + j--; + + for (k = 0; k < 10; k++) { + wsprintf(bufName,"rm%d%d%d",i,j,k); + _makepath(fn,bufDrive,bufDir,bufName,".bmp"); + h = CreateFile(fn,GENERIC_READ,FILE_SHARE_READ, NULL,OPEN_EXISTING,FILE_ATTRIBUTE_NORMAL, NULL); + if (h==INVALID_HANDLE_VALUE) + break; + CloseHandle(h); + } + + if (k == 10) { + k = 0; + j++; + if (j == 10) { + j = 0; + i++; + if (i == 10) + return false; + } + + wsprintf(bufName,"rm%d%d%d",i,j,k); + _makepath(fn,bufDrive,bufDir,bufName,".bmp"); + } +#endif + return true; +} + +void RMSnapshot::GrabScreenshot(byte *lpBuf, int dezoom, uint16 *lpDestBuf) { +#ifdef REFACTOR_ME + uint16 *src = (uint16 *)lpBuf; + + int dimx = RM_SX / dezoom; + int dimy = RM_SY / dezoom; + + int u, v, curv; + + uint16 appo; + uint32 k = 0; + int sommar, sommab, sommag; + uint16 *cursrc; + + if (lpDestBuf == NULL) + src += (RM_SY - 1) * RM_BBX; + + if (dezoom == 1 && 0) { // @@@ NON E' TESTATA MOLTO BENE!!! + byte *curOut = rgb; + + for (int y = 0; y < dimy; y++) { + for (int x = 0; x < dimx; x++) { + cursrc = &src[RM_SKIPX + x]; + + *curOut++ = ((*cursrc) & 0x1F) << 3; + *curOut++ = (((*cursrc) >> 5) & 0x1F) << 3; + *curOut++ = (((*cursrc) >> 10) & 0x1F) << 3; + + if (lpDestBuf) + *lpDestBuf++ = *cursrc; + } + + if (lpDestBuf == NULL) + src -= RM_BBX; + else + src += RM_BBX; + } + } else { + for (int y = 0; y < dimy; y++) { + for(int x = 0; x < dimx; x++) { + cursrc = &src[RM_SKIPX + x * dezoom]; + sommar = sommab = sommag = 0; + + for (v = 0; v < dezoom; v++) + for (u = 0; u < dezoom; u++) { + if (lpDestBuf == NULL) + curv = -v; + else + curv = v; + + sommab += cursrc[curv*RM_BBX + u] & 0x1F; + sommag += (cursrc[curv*RM_BBX + u] >> 5) & 0x1F; + sommar += (cursrc[curv*RM_BBX + u] >> 10) & 0x1F; + } + + rgb[k + 0] = (byte) (sommab * 8 / (dezoom * dezoom)); + rgb[k + 1] = (byte) (sommag * 8 / (dezoom * dezoom)); + rgb[k + 2] = (byte) (sommar * 8 / (dezoom * dezoom)); + + if (lpDestBuf!=NULL) + lpDestBuf[k/3] = ((int)rgb[k+0]>>3) | (((int)rgb[k+1]>>3)<<5) | (((int)rgb[k+2]>>3)<<10); + + k+=3; + } + + if (lpDestBuf == NULL) + src -= RM_BBX * dezoom; + else + src += RM_BBX * dezoom; + } + } + + + if (lpDestBuf == NULL) { + if (!GetFreeSnapName(filename)) + return; + + HANDLE hFile = CreateFile(filename, + GENERIC_WRITE, + 0, + NULL, + CREATE_ALWAYS, + FILE_ATTRIBUTE_NORMAL | FILE_FLAG_SEQUENTIAL_SCAN, + NULL); + + BITMAPFILEHEADER bmfHeader; + bmfHeader.bfType = ((uint16) ('M' << 8) | 'B'); + bmfHeader.bfSize = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER) + dimx * dimy * 3; + bmfHeader.bfReserved1 = 0; + bmfHeader.bfReserved2 = 0; + bmfHeader.bfOffBits = sizeof(BITMAPFILEHEADER) + sizeof(BITMAPINFOHEADER); + + BITMAPINFOHEADER bmiHeader; + bmiHeader.biSize = sizeof(BITMAPINFOHEADER); + bmiHeader.biWidth = dimx; + bmiHeader.biHeight = dimy; + bmiHeader.biPlanes = 1; + bmiHeader.biBitCount = 24; + bmiHeader.biCompression = BI_RGB; + bmiHeader.biSizeImage = dimx * dimy * 3; + bmiHeader.biXPelsPerMeter = 0xB12; + bmiHeader.biYPelsPerMeter = 0xB12; + bmiHeader.biClrUsed = 0; + bmiHeader.biClrImportant = 0; + + uint32 dwWritten; + WriteFile(hFile, &bmfHeader, sizeof(BITMAPFILEHEADER), &dwWritten, NULL); + WriteFile(hFile, &bmiHeader, sizeof(BITMAPINFOHEADER), &dwWritten, NULL); + + WriteFile(hFile, rgb, dimx * dimy * 3, &dwWritten, NULL); + CloseHandle(hFile); + } +#endif +} + +} // End of namespace Tony |