mm7: Render.cpp comparison

comparison Render.cpp @ 2069:259df09dfb50

32bits almost there

author	Nomad
date	Tue, 03 Dec 2013 20:18:17 +0200
parents	b2a434d65344
children	38bf1c70fc70

comparison

equal deleted inserted replaced

-:b2a434d65344
+:259df09dfb50
 HRESULT __stdcall DDrawDisplayModesEnumerator(DDSURFACEDESC2 *pSurfaceDesc, __int16 *a2);
 HRESULT __stdcall D3DDeviceEnumerator(const GUID *lpGUID, const char *lpDeviceDesc, const char *lpDeviceName, D3DDEVICEDESC *pHWDesc, D3DDEVICEDESC *pSWDesc, struct RenderD3D_aux *a6);
 signed int __stdcall RenderD3D__DeviceEnumerator(GUID *lpGUID, const char *lpDevDesc, const char *lpDriverName, RenderD3D__DevInfo *pOut); // idb
 //----- (0049E79F) --------------------------------------------------------
-bool  CheckTextureStages()
+bool CheckTextureStages()
 {
 bool v0; // edi@1
 IDirectDrawSurface4 *pSurface2; // [sp+Ch] [bp-14h]@1
 IDirectDrawSurface4 *pSurface1; // [sp+10h] [bp-10h]@1
 DWORD v4; // [sp+14h] [bp-Ch]@1
 //----- (0049D717) --------------------------------------------------------
 HRESULT __stdcall D3DZBufferFormatEnumerator(DDPIXELFORMAT *Src, DDPIXELFORMAT *Dst)
 {
 HRESULT v2; // esi@2
-if ( Src->dwFlags & 0x400 | 0x2000 )
+if ( Src->dwFlags & (0x400 | 0x2000))
 {
 v2 = 0;
 if ( Src->dwRGBBitCount == 16 && !Src->dwRBitMask )
 goto LABEL_6;
 if ( !Dst->dwSize )
 v1->pHost = 0;
 }
 }
 //----- (0049DE14) --------------------------------------------------------
-bool RenderD3D::CreateDevice(unsigned int uDeviceID, int bWindowed, HWND hWnd)
+bool RenderD3D::CreateDevice(unsigned int uDeviceID, int bWindowed, OSWindow *window)
 {
 //IDirectDraw4 *v8; // eax@12
 //IDirectDraw4 *v9; // eax@16
 //IDirectDraw4 *v10; // eax@20
 //IDirectDraw4 *v13; // eax@35
 DDSURFACEDESC2 ddsd2; // [sp+1Ch] [bp-BCh]@11
 D3DVIEWPORT2 d3dvp2; // [sp+98h] [bp-40h]@28
 IDirectDrawClipper *v30; // [sp+C4h] [bp-14h]@18
 LPDIRECTDRAW lpDD; // [sp+C8h] [bp-10h]@1
+auto hWnd = window->GetApiHandle();
+int game_width = window->GetWidth();
+int game_height = window->GetHeight();
 this->bWindowed = bWindowed;
 this->hWindow = hWnd;
 if (FAILED(DirectDrawCreate(pAvailableDevices[uDeviceID].pDirectDrawGUID, &lpDD, 0)))
 {
 ddsd2.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE;
 if ( !pHost->CreateSurface(&ddsd2, &pFrontBuffer, 0) )
 {
 ddsd2.dwSize = sizeof(DDSURFACEDESC2);
 pHost->GetDisplayMode(&ddsd2);
-if ( ddsd2.ddpfPixelFormat.dwRGBBitCount != 16 )
+if ( FORCE_16_BITS && ddsd2.ddpfPixelFormat.dwRGBBitCount != 16 )
 {
 v24 = "Init - Desktop isn't in 16 bit mode.\n";
 goto LABEL_14;
 }
 ddsd2.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT;
 ddsd2.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_3DDEVICE;
-ddsd2.dwWidth = 640;
+ddsd2.dwWidth = game_width;
-ddsd2.dwHeight = 480;
+ddsd2.dwHeight = game_height;
 if (pHost->CreateSurface(&ddsd2, &pBackBuffer, 0) )
 {
 v24 = "Init - Failed to create back buffer.\n";
 LABEL_14:
 sprintf(pErrorMessage, v24);
 pHost->QueryInterface(IID_IDirect3D3, (LPVOID *)&pDirect3D);
 ddsd2.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT;
 ddsd2.ddsCaps.dwCaps = DDSCAPS_ZBUFFER;
-ddsd2.dwWidth = 640;
+ddsd2.dwWidth = game_width;
-ddsd2.dwHeight = 480;
+ddsd2.dwHeight = game_height;
 if ( pDirect3D->EnumZBufferFormats(*pAvailableDevices[uDeviceID].pGUID,
 (HRESULT (__stdcall *)(DDPIXELFORMAT *, void *))D3DZBufferFormatEnumerator,
 &ddsd2.ddpfPixelFormat) )
 goto LABEL_21;
 d3dvp2.dvMaxZ = 1.0;
 LABEL_54:
 d3dvp2.dwSize = sizeof(D3DVIEWPORT2);
 //v17 = *hWnda;
-d3dvp2.dwWidth = 640;
+d3dvp2.dwWidth = game_width;
-d3dvp2.dwHeight = 480;
+d3dvp2.dwHeight = game_height;
 d3dvp2.dvClipX = -1.0;
 //v18 = v17->lpVtbl;
 //v32 = &v4->pViewport;
 if (pDirect3D->CreateViewport(&pViewport, 0))
 {
 v1->pColorKeySurface4 = 0;
 v1->pDirectDraw4 = 0;
 v1->pRenderD3D = 0;
 v1->uNumSceneBegins = 0;
 v1->uNumD3DSceneBegins = 0;
-v1->field_40110 = 0;
+v1->using_software_screen_buffer = 0;
 v1->pTargetSurface = 0;
 v1->uTargetSurfacePitch = 0;
 v1->uClipY = 0;
 v1->uClipX = 0;
 v1->uClipW = 480;
 v1->bClip = 1;
-v1->bColorKeySupported = 0;
+//v1->bColorKeySupported = 0;
 v1->bRequiredTextureStagesAvailable = 0;
 v1->bTinting = 1;
 LOBYTE(v1->field_103668) = 0;
 v1->field_1036B8 = 0;
 v1->_gpu_memory_used = 0;
 hd_water_tile_id = -1;
 hd_water_current_frame = 0;
 sub_4A19B0();
 }
-bool Render::Initialize(bool bWindowed, OSWindow *window, bool bColoredLights, uint32_t uDetailLevel, bool bTinting)
+bool Render::Initialize(OSWindow *window, bool bColoredLights, uint32_t uDetailLevel, bool bTinting)
 {
 //bUserDirect3D = true;//ReadWindowsRegistryInt("Use D3D", 0);
 this->window = window;
-bStartInWindow = bWindowed;
+//bStartInWindow = true;
 //windowed_mode_width = windowed_width;
 //windowed_mode_height = windowed_height;
 uDesiredDirect3DDevice = ReadWindowsRegistryInt("D3D Device", 0);
 bool r2 = pD3DSprites.Load(L"data\\d3dsprite.hwl");
 return r1 && r2;
 }
-//----- (0049EBF1) --------------------------------------------------------
-void Render::_49EBF1()
-{
-signed int uNumRedBits; // edx@1
-signed int uNuGreenBits; // edi@1
-signed int uNumBlueBits; // esi@1
-unsigned int v4; // edx@4
-unsigned int v5; // edi@4
-int v6; // ebx@4
-int v7; // edx@4
-signed int v8; // [sp+8h] [bp-24h]@1
-signed int v9; // [sp+Ch] [bp-20h]@1
-signed int v10; // [sp+20h] [bp-Ch]@1
-signed int i; // [sp+24h] [bp-8h]@2
-signed int v12; // [sp+28h] [bp-4h]@3
-v10 = 0;
-uNumRedBits = 1 << this->uTargetRBits;
-uNuGreenBits = 1 << this->uTargetGBits;
-uNumBlueBits = 1 << this->uTargetBBits;
-v9 = 1 << this->uTargetRBits;
-v8 = 1 << this->uTargetGBits;
-if ( uNumRedBits > 0 )
-{
-do
-{
-for ( i = 0; i < uNuGreenBits; ++i )
-{
-v12 = 0;
-if ( uNumBlueBits > 0 )
-{
-do
-{
-v4 = this->uTargetBBits;
-v5 = v4 + this->uTargetGBits;
-v6 = (v12 >> 1) + (v10 >> 1 << v5) + (i >> 1 << this->uTargetBBits);
-v7 = (v10 << v5) + v12++ + (i << v4);
-this->field_2C[v7] = v6;
-}
-while ( v12 < uNumBlueBits );
-uNumRedBits = v9;
-uNuGreenBits = v8;
-}
-}
-++v10;
-}
-while ( v10 < uNumRedBits );
-}
-}
 //----- (0049ECC4) --------------------------------------------------------
 void Render::ClearBlack()
 {
 if (pRenderD3D)
 {
-if (field_40110)
+if (using_software_screen_buffer)
 pRenderD3D->ClearTarget(true, 0, false, 0.0);
 }
 else
 memset(pRenderer->pTargetSurface, 0, 4 * (field_10 * field_14 / 2));
 }
 int i; // [sp+15Ch] [bp-8h]@10
 unsigned __int8 v34; // [sp+163h] [bp-1h]@17
 v1 = this;
 v2 = 0;
-if ( !this->pRenderD3D || this->field_40110 )
+if ( !this->pRenderD3D || this->using_software_screen_buffer )
 {
 sprintf(Filename, "screen%0.2i.pcx", dword_4EFA80++ % 100);
 File = fopen(Filename, "wb");
 if ( File )
 {
 }
 }
 // 4EFA80: using guessed type int dword_4EFA80;
 //----- (0049F1BC) --------------------------------------------------------
-void Render::_49F1BC(const char *a1)
+void Render::SaveWinnersCertificate(const char *a1)
 {
 Render *v2; // esi@1
 __int16 v3; // di@1
 int v4; // eax@4
 char *v5; // ecx@4
 char *i; // [sp+130h] [bp-8h]@10
 unsigned __int8 v46; // [sp+137h] [bp-1h]@17
 v2 = this;
 v3 = 0;
-if ( !this->pRenderD3D || this->field_40110 )
+if ( !this->pRenderD3D || this->using_software_screen_buffer )
 {
 ++dword_4EFA84;
 File = fopen(a1, "wb");
 if ( File )
 {
 v3 = 0;
 }
 else
 {
 pRenderer->BeginScene();
-v42 = pRenderer->pTargetSurface;
+//v42 = pRenderer->pTargetSurface;
 v6 = pRenderer->uTargetSurfacePitch;
 }
 i = (char *)v6;
 v33 = v25 - 1;
 v31 = v3;
 //----- (0049FBCD) --------------------------------------------------------
 void Render::ClearTarget(unsigned int uColor)
 {
 if (pRenderD3D)
 {
-if (field_40110)
+if (using_software_screen_buffer)
 pRenderD3D->ClearTarget(true, uColor, false, 0.0);
 }
 else
 memset32(pTargetSurface, uColor, field_10 * field_14 / 2);
 }
 struct tagRECT Rect; // [sp+8h] [bp-28h]@11
 RECT a4; // [sp+18h] [bp-18h]@11
 struct tagPOINT Point; // [sp+28h] [bp-8h]@11
 v1 = this;
-if ( !pRenderer->pRenderD3D || this->field_40110 )
+if ( !pRenderer->pRenderD3D || this->using_software_screen_buffer )
 {
 this->pBeforePresentFunction();
 if ( v1->pRenderD3D )
 {
-if ( v1->field_40110 )
+if ( v1->using_software_screen_buffer )
 {
 pRenderD3D->Present(false);
 }
 }
 else __debugbreak(); // no sr
 void **v16; // esi@29
 v1 = this;
 if (pRenderD3D)
 {
-if ( v1->field_40110 )
+if ( v1->using_software_screen_buffer )
 {
 pRenderD3D->ClearTarget(true, 0, false, 1.0);
 pRenderD3D->Present(0);
 pRenderD3D->ClearTarget(true, 0, false, 1.0);
 }
 v1->pBackBuffer4 = 0;
 v1->pFrontBuffer4 = 0;
 v1->pDirectDraw4 = 0;
 if (v1->pTargetSurface)
 {
-free(v1->ptr_400E8);
+delete [] v1->pTargetSurface_unaligned;
 v1->pTargetSurface = 0;
-v1->ptr_400E8 = 0;
+v1->pTargetSurface_unaligned = 0;
 }
 if (pRenderD3D)
 {
 pRenderD3D->Release();
 delete pRenderD3D;
 RenderD3D *v11; // eax@25
 HRESULT v12; // eax@25
 int v13; // ecx@25
 int v14; // eax@27
 signed int v15; // ebx@31
-bool v16; // eax@35
+//bool v16; // eax@35
-char v17; // zf@35
+//char v17; // zf@35
 IDirectDraw4 *v18; // eax@38
 HRESULT v19; // eax@38
-int *v20; // eax@39
+//int *v20; // eax@39
 int *v22; // eax@42
 int v23; // ecx@42
 D3DDEVICEDESC refCaps; // [sp+Ch] [bp-300h]@25
 DDSURFACEDESC2 pDesc; // [sp+108h] [bp-204h]@40
 D3DDEVICEDESC halCaps; // [sp+184h] [bp-188h]@25
 DDSURFACEDESC2 ddsd2; // [sp+280h] [bp-8Ch]@38
 void *v28; // [sp+2FCh] [bp-10h]@2
 int v29; // [sp+308h] [bp-4h]@2
+__debugbreak(); // Nomad
 //v2 = this;
-this->field_40110 = 0;
+this->using_software_screen_buffer = 0;
 this->pColorKeySurface4 = 0;
 this->pBackBuffer4 = 0;
 this->pFrontBuffer4 = 0;
 this->pDirectDraw4 = 0;
-this->bColorKeySupported = 0;
+//this->bColorKeySupported = 0;
 Release();
 //v3 = hWnd;
 this->window = window;
 CreateZBuffer();
 v6 = uDesiredDirect3DDevice;
 v29 = -1;
 v7 = pRenderD3D->pAvailableDevices;
 if ( v7[v6].bIsDeviceCompatible )
 {
-v8 = pRenderD3D->CreateDevice(v6, 0, window->GetApiHandle());
+v8 = pRenderD3D->CreateDevice(v6, /*0*/true, window);
 uAcquiredDirect3DDevice = uDesiredDirect3DDevice;
 }
 else
 {
 if ( v7[1].bIsDeviceCompatible )
 {
-v8 = pRenderD3D->CreateDevice(1u, 0, window->GetApiHandle());
+v8 = pRenderD3D->CreateDevice(1, /*0*/true, window);
 uAcquiredDirect3DDevice = 1;
 }
 else
 {
 if ( !v7->bIsDeviceCompatible )
 Error("There aren't any D3D devices to create.");
-v8 = pRenderD3D->CreateDevice(0, 0, window->GetApiHandle());
+v8 = pRenderD3D->CreateDevice(0, /*0*/true, window);
 uAcquiredDirect3DDevice = 1;
 }
 }
 if ( !v8 )
 Error("D3Drend->Init failed.");
 ErrD3D(pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, 2u));
 ErrD3D(pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_COLORARG1, 2u));
 ErrD3D(pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_COLORARG2, 0));
 ErrD3D(pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_COLOROP, 4u));
 //}
-ddpfPrimareSuface.dwSize = 32;
+ddpfPrimarySuface.dwSize = 32;
-GetTargetPixelFormat(&ddpfPrimareSuface);
+GetTargetPixelFormat(&ddpfPrimarySuface);
 ParseTargetPixelFormat();
-_49EBF1();
-if ( pRenderD3D )
+if (!pRenderD3D)
 {
-v16 = IsColorKeySupported(pDirectDraw4);
+__debugbreak();
+pBeforePresentFunction = 0;//nullsub_1;
+}
+//else
+//{
+/*v16 = IsColorKeySupported(pDirectDraw4);
 v17 = uAcquiredDirect3DDevice == v15;
 bColorKeySupported = v16;
 if ( !v17 )
 bColorKeySupported = 0;
 if ( bColorKeySupported )
 ddsd2.dwWidth = 640;
 ddsd2.dwHeight = 480;
 ErrD3D(v18->CreateSurface(&ddsd2, &pColorKeySurface4, 0));
 pBeforePresentFunction = Present_ColorKey;
 }
-else
+else*/
 {
 pTargetSurface = 0;
-ptr_400E8 = 0;
+pTargetSurface_unaligned = 0;
-v20 = (int *)malloc(0x96020u);
+pTargetSurface_unaligned = (unsigned int *)malloc(640 * 480 * 2 + 32);
-ptr_400E8 = v20;
+if ( !pTargetSurface_unaligned
-if ( !v20
 || (memset(&pDesc, 0, 0x7Cu),
 pDesc.dwSize = 124,
 !pRenderer->LockSurface_DDraw4(pRenderer->pBackBuffer4, &pDesc, v15)) )
 return 0;
 pBackBuffer4->Unlock(0);
-v22 = ptr_400E8 + 4;
+v22 = (int *)pTargetSurface_unaligned + 4;
 v23 = (unsigned int)pDesc.lpSurface & 7;
 LOBYTE(v22) = (unsigned __int8)v22 & 0xF8;
 uTargetSurfacePitch = 640;
 pBeforePresentFunction = Present_NoColorKey;
 v15 = 1;
-pTargetSurface = (unsigned __int16 *)((char *)v22 + 2 * v23);
+pTargetSurface = (unsigned __int32 *)((char *)v22 + 2 * v23);
 }
-field_40110 = v15;
+using_software_screen_buffer = v15;
-}
+//}
-else
-{
-pBeforePresentFunction = 0;//nullsub_1;
-}
 bWindowMode = 0;
 pParty->uFlags |= 2u;
-LODWORD(flt_6BE3A0) = 0x3F0CCCCDu;  __debugbreak(); // replace with actual float
+flt_6BE3A0 = 0.55000001f;
 pViewport->_4C02F8(36044);
 return v15 != 0;
 }
 //----- (004A05F3) --------------------------------------------------------
 unsigned int v9; // eax@12
 RenderD3D *v10; // eax@24
 HRESULT v11; // eax@24
 int v12; // eax@24
 int v13; // eax@26
-bool v14; // eax@32
+//bool v14; // eax@32
-char v15; // zf@32
+//char v15; // zf@32
 IDirectDraw4 *v16; // eax@35
 HRESULT v17; // eax@35
-int *v18; // eax@36
+//int *v18; // eax@36
 int *v19; // edx@38
 int v20; // eax@38
 unsigned int v21; // ecx@38
 int v22; // eax@41
 D3DDEVICEDESC refCaps; // [sp+Ch] [bp-300h]@24
 D3DDEVICEDESC halCaps; // [sp+184h] [bp-188h]@24
 DDSURFACEDESC2 ddsd2; // [sp+280h] [bp-8Ch]@35
 //RenderD3D *thisa; // [sp+2FCh] [bp-10h]@2
 int v29; // [sp+308h] [bp-4h]@2
-pParty->uFlags |= 2u;
+pParty->uFlags |= PARTY_FLAGS_1_0002;
 //v2 = this;
 flt_6BE3A0 = 0.55000001f;
 pViewport->_4C02F8(36044);
-field_40110 = 0;
+using_software_screen_buffer = 0;
 Release();
 pColorKeySurface4 = 0;
 pBackBuffer4 = 0;
 pFrontBuffer4 = 0;
 pDirectDraw4 = 0;
-bColorKeySupported = 0;
+//bColorKeySupported = 0;
 CreateZBuffer();
 /*if (!bUserDirect3D)
 {
 CreateDirectDraw();
 SetDirectDrawCooperationMode(hWnd, 0);
 v29 = -1;
 //v6 = pRenderD3D->pAvailableDevices;
 if (pRenderD3D->pAvailableDevices[uDesiredDirect3DDevice].bIsDeviceCompatible &&
 uDesiredDirect3DDevice != 1 )
 {
-v7 = pRenderD3D->CreateDevice(uDesiredDirect3DDevice, 1, window->GetApiHandle());
+v7 = pRenderD3D->CreateDevice(uDesiredDirect3DDevice, true, window);
 uAcquiredDirect3DDevice = uDesiredDirect3DDevice;
 }
 else
 {
 if ( !pRenderD3D->pAvailableDevices[0].bIsDeviceCompatible )
 Error("There aren't any D3D devices to init.");
-v7 = pRenderD3D->CreateDevice(0, 1, window->GetApiHandle());
+v7 = pRenderD3D->CreateDevice(0, true, window);
 uAcquiredDirect3DDevice = 0;
 }
 if ( !v7 )
 Error("D3Drend->Init failed.");
 memset(&refCaps, 0, 0xFCu);
 //v10 = v2->pRenderD3D;
 refCaps.dwSize = 252;
 ErrD3D(pRenderD3D->pDevice->GetCaps(&halCaps, &refCaps));
 v12 = halCaps.dwMinTextureWidth;
-if ( (unsigned int)halCaps.dwMinTextureWidth >= halCaps.dwMinTextureHeight )
+if ( (unsigned int)halCaps.dwMinTextureWidth > halCaps.dwMinTextureHeight )
 v12 = halCaps.dwMinTextureHeight;
 uMinDeviceTextureDim = v12;
 v13 = halCaps.dwMaxTextureWidth;
 if ( (unsigned int)halCaps.dwMaxTextureWidth < halCaps.dwMaxTextureHeight )
 v13 = halCaps.dwMaxTextureHeight;
 ErrD3D(pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_COLORARG1, 2u));
 ErrD3D(pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_COLORARG2, 0));
 ErrD3D(pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_COLOROP, 4u));
 //}
-ddpfPrimareSuface.dwSize = 32;
+ddpfPrimarySuface.dwSize = 32;
-GetTargetPixelFormat(&ddpfPrimareSuface);
+GetTargetPixelFormat(&ddpfPrimarySuface);
 ParseTargetPixelFormat();
-_49EBF1();
 if ( !pRenderD3D )
 {
-pBeforePresentFunction = 0;//nullsub_1;
+__debugbreak();
-goto LABEL_47;
+//pBeforePresentFunction = 0;//nullsub_1;
-}
+//goto LABEL_47;
-v14 = IsColorKeySupported(pDirectDraw4);
+}
+/*v14 = IsColorKeySupported(pDirectDraw4);
 v15 = uAcquiredDirect3DDevice == 1;
 bColorKeySupported = v14;
 if ( !v15 )
-bColorKeySupported = 0;
+bColorKeySupported = 0;*/
-if ( bColorKeySupported )
+//if ( bColorKeySupported )
-{
+if (false)
-memset(&ddsd2, 0, 0x7Cu);
+{
+/*memset(&ddsd2, 0, 0x7Cu);
 ddsd2.ddckCKSrcBlt.dwColorSpaceLowValue = uTargetGMask | uTargetBMask;
 ddsd2.ddckCKSrcBlt.dwColorSpaceHighValue = ddsd2.ddckCKSrcBlt.dwColorSpaceLowValue;
 v16 = pDirectDraw4;
 ddsd2.dwSize = 124;
 ddsd2.dwFlags = 65543;
 ddsd2.ddsCaps.dwCaps = 2112;
 ddsd2.dwWidth = 640;
 ddsd2.dwHeight = 480;
 ErrD3D(v16->CreateSurface(&ddsd2, &pColorKeySurface4, 0));
-pBeforePresentFunction = Present_ColorKey;
+pBeforePresentFunction = Present_ColorKey;*/
 LABEL_45:
-field_40110 = 1;
+using_software_screen_buffer = 1;
-LABEL_47:
+//LABEL_47:
 bWindowMode = 1;
 //hWnd = hWnd;
 return 0;
 }
 pTargetSurface = 0;
-ptr_400E8 = 0;
+pTargetSurface_unaligned = 0;
-v18 = (int *)new char[0x96020];
-memset(v18, -1, 0x96020);
+uint num_pixels = window->GetWidth() * window->GetHeight();
-ptr_400E8 = v18;
+pTargetSurface_unaligned = new unsigned int[num_pixels];
-if ( v18 )
-{
+if (!pTargetSurface_unaligned)
-memset(&pDesc, 0, 0x7Cu);
+return false;
-pDesc.dwSize = 124;
-if ( pRenderer->LockSurface_DDraw4(pRenderer->pBackBuffer4, &pDesc, DDLOCK_WAIT) )
+memset(&pDesc, 0, 0x7Cu);
-{
+pDesc.dwSize = 124;
+if (!pRenderer->LockSurface_DDraw4(pRenderer->pBackBuffer4, &pDesc, DDLOCK_WAIT))
+{
+delete [] pTargetSurface_unaligned;
+return false;
+}
+memset32(pTargetSurface_unaligned, -1, num_pixels);
 pRenderer->pBackBuffer4->Unlock(0);
-v19 = ptr_400E8;
+/*v19 = pTargetSurface_unaligned;
 v20 = (unsigned int)pDesc.lpSurface & 7;
 v21 = (unsigned int)ptr_400E8 & 7;
 if ( v21 == v20 )
 {
 pTargetSurface = (unsigned __int16 *)v19;
 if ( (signed int)v21 >= v20 )
 v22 = (int)((char *)v19 + 2 * (v21 - v20) + 16);
 else
 v22 = (int)((char *)v19 + 2 * (v20 - v21) + 16);
 pTargetSurface = (unsigned __int16 *)v22;
-}
+}*/
-uTargetSurfacePitch = 640;
+pTargetSurface = pTargetSurface_unaligned;
+uTargetSurfacePitch = window->GetWidth();
 pBeforePresentFunction = Present_NoColorKey;
 goto LABEL_45;
-}
-}
-return 0;
 }
 //----- (004A0BEE) --------------------------------------------------------
 char Render::RasterLine2D(unsigned int uX, unsigned int uY, unsigned int uZ, unsigned int uW, unsigned __int16 uColor)
 {
 {
 uXa = -uXa;
 v24 = -1;
 }
 v25 = 0;
-v26 = v35->pTargetSurface;
+__debugbreak(); //target sruface will most likely be 32bits/pixel, but this sub awaits 16 bits
+v26 = (unsigned __int16 *)v35->pTargetSurface;
 if ( v26 )
 {
 if ( (signed int)uXa <= v23 )
 {
 v30 = v23 + 1;
 DWORD uRedMask; // edx@1
 unsigned int uGreenMask; // esi@5
 signed int v5; // ecx@5
 unsigned int uBlueMask; // edx@9
 signed int v7; // ecx@9
-unsigned int v8; // ecx@13
+//unsigned int v8; // ecx@13
 v1 = this;
 v2 = 0;
-uRedMask = v1->ddpfPrimareSuface.dwRBitMask;
+uRedMask = v1->ddpfPrimarySuface.dwRBitMask;
 v1->uTargetBBits = 0;
 v1->uTargetGBits = 0;
 v1->uTargetRBits = 0;
 do
 {
 if ( (1 << v2) & uRedMask )
 ++v1->uTargetRBits;
 ++v2;
 }
-while ( v2 < 16 );
+while ( v2 < 32 );
-uGreenMask = v1->ddpfPrimareSuface.dwGBitMask;
+uGreenMask = v1->ddpfPrimarySuface.dwGBitMask;
 v5 = 0;
 do
 {
 if ( (1 << v5) & uGreenMask )
 ++v1->uTargetGBits;
 ++v5;
 }
-while ( v5 < 16 );
+while ( v5 < 32 );
-uBlueMask = v1->ddpfPrimareSuface.dwBBitMask;
+uBlueMask = v1->ddpfPrimarySuface.dwBBitMask;
 v7 = 0;
 do
 {
 if ( (1 << v7) & uBlueMask )
 ++v1->uTargetBBits;
 ++v7;
 }
-while ( v7 < 16 );
+while ( v7 < 32 );
-v8 = v1->ddpfPrimareSuface.dwRBitMask;
 v1->uTargetGMask = uGreenMask;
-v1->uTargetRMask = v8;
+v1->uTargetRMask = v1->ddpfPrimarySuface.dwRBitMask;
 v1->uTargetBMask = uBlueMask;
 }
 //----- (004A0F40) --------------------------------------------------------
 bool Render::LockSurface_DDraw4(IDirectDrawSurface4 *pSurface, DDSURFACEDESC2 *pDesc, unsigned int uLockFlags)
 pBillboardRenderListD3D[v8].uOpacity = RenderBillboardD3D::Opaque_3;
 else
 pBillboardRenderListD3D[v8].uOpacity = RenderBillboardD3D::Transparent;
 }
-//----- (004A48E4) --------------------------------------------------------
-int Render::MakeParticleBillboardAndPush_BLV_Software(int screenSpaceX, int screenSpaceY, int z, int lightColor, int a6)
-{
-int v6; // ecx@1
-int v7; // ebx@1
-int v8; // ecx@1
-int v9; // edx@1
-int v10; // edi@1
-unsigned int x; // esi@1
-int result; // eax@8
-int v13; // [sp+Ch] [bp-10h]@1
-int v14; // [sp+10h] [bp-Ch]@1
-int v15; // [sp+14h] [bp-8h]@1
-int v16; // [sp+18h] [bp-4h]@1
-int v17; // [sp+24h] [bp+8h]@1
-unsigned int v18; // [sp+28h] [bp+Ch]@1
-int v19; // [sp+34h] [bp+18h]@1
-v6 = screenSpaceX;
-v7 = (a6 >> 1) + screenSpaceY;
-v17 = 0;
-v15 = 0;
-v8 = (a6 >> 1) + v6;
-v14 = (a6 >> 1) * (a6 >> 1);
-v9 = 2 * (a6 >> 1);
-v10 = (a6 >> 1) * ((a6 >> 1) - 1);
-x = v8 - (a6 >> 1);
-v16 = (a6 >> 1) + screenSpaceY - v8;
-v19 = a6 >> 1;
-v13 = v9;
-v18 = v8;
-do
-{
-sr_4A46E6_draw_particle_segment(x, v16 + v18, z, 2 * v19, lightColor);
-if ( v15 )
-sr_4A46E6_draw_particle_segment(x, v17 + v7, z, 2 * v19, lightColor);
-v14 -= v15;
-if ( v14 <= v10 )
-{
-if ( v19 != v17 )
-{
-sr_4A46E6_draw_particle_segment(v18, v16 + x, z, 2 * v17, lightColor);
-sr_4A46E6_draw_particle_segment(v18, v19 + v7, z, 2 * v17, lightColor);
-}
---v19;
-v13 -= 2;
-++x;
-v10 -= v13;
-}
-result = v17++;
-v15 += 2;
---v18;
-}
-while ( result < v19 );
-return result;
-}
 //----- (004A49D0) --------------------------------------------------------
 void Render::DrawProjectile(float srcX, float srcY, float a3, float a4, float dstX, float dstY, float a7, float a8, IDirect3DTexture2 *a9)
 {
 int absXDifference; // eax@1
 this->uNumSceneBegins = v2 + 1;
 if ( !v2 )
 {
 if ( this->pRenderD3D )
 {
-if ( this->bColorKeySupported )
+/*if ( this->bColorKeySupported )
 {
 memset(&Dst, 0, 0x7Cu);
 Dst.dwSize = 124;
 if ( LockSurface_DDraw4(this->pColorKeySurface4, &Dst, 0x800 | DDLOCK_WAIT) )
 {
 this->pTargetSurface = (unsigned __int16 *)Dst.lpSurface;
 this->uTargetSurfacePitch = Dst.lPitch >> 1;
 this->field_18_locked_pitch = Dst.lPitch >> 1;
 }
 --this->uNumSceneBegins;
-}
+}*/
 }
 else
 {
 if ( !this->pTargetSurface )
 {
 this->uNumSceneBegins--;
 if ( !this->uNumSceneBegins )
 {
 if ( this->pRenderD3D )
 {
-if ( this->bColorKeySupported )
+/*if ( this->bColorKeySupported )
 {
 this->pTargetSurface = 0;
 this->uTargetSurfacePitch = 0;
 this->field_18_locked_pitch = 0;
 ErrD3D(this->pColorKeySurface4->Unlock(0));
-}
+}*/
 }
 else
 {
 this->pTargetSurface = 0;
 this->uTargetSurfacePitch = 0;
 this->bClip = 1;
 this->uClipW = 480;
 this->uClipZ = 640;
 }
+unsigned __int32 Color32(unsigned __int16 color16)
+{
+unsigned __int32 c = color16;
+unsigned int b = (c & 31) * 8;
+unsigned int g = ((c >> 5) & 63) * 4;
+unsigned int r = ((c >> 11) & 31) * 8;
+return 0xFF000000 | (r << 16) | (g << 8) | b;
+}
+//----- (0040DEF3) --------------------------------------------------------
+unsigned __int16 Color16(unsigned __int32 r, unsigned __int32 g, unsigned __int32 b)
+{
+//return ((unsigned int)b >> (8 - LOBYTE(pRenderer->uTargetBBits))) | pRenderer->uTargetGMask & (g << (LOBYTE(pRenderer->uTargetGBits) +
+//                         LOBYTE(pRenderer->uTargetBBits) - 8)) | pRenderer->uTargetRMask & (r << (LOBYTE(pRenderer->uTargetGBits) +
+//                         LOBYTE(pRenderer->uTargetRBits) + LOBYTE(pRenderer->uTargetBBits) - 8));
+return (b >> (8 - 5)) |
+0x7E0 & (g << (6 + 5 - 8)) |
+0xF800 & (r << (6 + 5 + 5 - 8));
+}
 //----- (004A5BE3) --------------------------------------------------------
 void Render::DrawTextureRGB(unsigned int uOutX, unsigned int uOutY, RGBTexture *a4)
 {
 int v4; // edi@3
-unsigned __int16 *v5; // edx@3
+//unsigned __int16 *v5; // edx@3
 unsigned __int16 *v6; // esi@3
 unsigned int v8; // eax@5
 unsigned int v9; // ebx@5
 unsigned int v11; // eax@7
 unsigned int v12; // ebx@8
 int v23; // [sp+28h] [bp+10h]@3
 if ( this->uNumSceneBegins && a4 )
 {
 v4 = a4->uWidth;
-v5 = &this->pTargetSurface[uOutX + uOutY * this->uTargetSurfacePitch];
+//v5 = &this->pTargetSurface[uOutX + uOutY * this->uTargetSurfacePitch];
 v6 = a4->pPixels;
 v23 = a4->uHeight;
 v19 = v4;
 if ( this->bClip )
 {
 v8 = this->uClipX - uOutX;
 v9 = uOutX - this->uClipX;
 v8 *= 2;
 v4 += v9;
 v6 = (unsigned __int16 *)((char *)v6 + v8);
-v5 = (unsigned __int16 *)((char *)v5 + v8);
+//v5 = (unsigned __int16 *)((char *)v5 + v8);
 }
 if ( (signed int)uOutY < (signed int)this->uClipY )
 {
 v11 = this->uClipY - uOutY;
 v6 += v19 * v11;
 v23 += uOutY - this->uClipY;
-v5 += this->uTargetSurfacePitch * v11;
+//v5 += this->uTargetSurfacePitch * v11;
 }
 v12 = max(this->uClipX, uOutX);
 if ( (signed int)(v4 + v12) > (signed int)this->uClipZ )
 {
 v4 = this->uClipZ - max(this->uClipX, uOutX);
 {
 v23 = this->uClipW - max(this->uClipY, uOutY);
 }
 }
-for (int outerCounter = 0; outerCounter < v23; outerCounter++)
+for (int y = 0; y < v23; y++)
 {
-for (int counter = 0; counter < v4; counter++)
+for (int x = 0; x < v4; x++)
 {
-*v5 = *v6;
+WritePixel16(uOutX + x, uOutY + y, *v6);
-++v5;
+//*v5 = *v6;
+//++v5;
 ++v6;
 }
 v6 += v19 - v4;
-v5 += this->uTargetSurfacePitch - v4;
+//v5 += this->uTargetSurfacePitch - v4;
 }
 }
 }
 //----- (004A5D33) --------------------------------------------------------
 void Render::CreditsTextureScroll(unsigned int pX, unsigned int pY, int move_X, int move_Y, RGBTexture *pTexture)
 {
-unsigned __int16 *v7; // ebx@3
+//unsigned __int16 *v7; // ebx@3
 int full_width; // ecx@3
 int full_height; // edi@3
-int v23; // edi@23
+//int v23; // edi@23
 unsigned __int16 *pTexturea; // [sp+28h] [bp+18h]@3
 if ( this->uNumSceneBegins && pTexture )
 {
-v7 = &this->pTargetSurface[pX + pY * this->uTargetSurfacePitch];
+/*auto v7 = this->pTargetSurface;
+if (FORCE_16_BITS)
+v7 = (unsigned __int32 *)((char *)v7 + (pX + pY * this->uTargetSurfacePitch) * 2);
+else
+v7 = (unsigned __int32 *)((char *)v7 + (pX + pY * this->uTargetSurfacePitch) * 4);*/
 full_width = pTexture->uWidth - move_X;
 full_height = pTexture->uHeight - move_Y;
 pTexturea = &pTexture->pPixels[move_X + move_Y * pTexture->uWidth];
 if ( this->bClip )
 {
 if ( pX < this->uClipX )//���� ���� ������� �� ������ �������
 {
 pTexturea = (unsigned __int16 *)((char *)pTexturea + (2 * (this->uClipX - pX)));
 full_width += pX - this->uClipX;
-v7 = (unsigned __int16 *)((char *)v7 + (2 * (this->uClipX - pX)));
+//v7 = (unsigned __int32 *)((char *)v7 + ((FORCE_16_BITS ? 2 : 4) * (this->uClipX - pX)));
 }
 if ( pY < this->uClipY )//���� ���� ������� �� ������� �������
 {
 pTexturea += pTexture->uWidth * (this->uClipY - pY);
 full_height += pY - this->uClipY;
-v7 += this->uTargetSurfacePitch * (this->uClipY - pY);
+//v7 = (unsigned __int32 *)((char *)v7 + (FORCE_16_BITS ? 2 : 4) * this->uTargetSurfacePitch * (this->uClipY - pY));
 }
 if ( this->uClipX < pX )//���� ������ ������� ���� ������ � ���������� �����
 this->uClipX = pX;
 if ( this->uClipY < pY )//���� ������� ������� ���� ������ y ���������� �����
 this->uClipY = pY;
 if ( this->uClipY < pY )
 this->uClipY = pY;
 full_height = this->uClipW - this->uClipY;
 }
 }
-if ( full_height > 0 )
-{
+for (int y = 0; y < full_height; ++y)
-do
+{
-{
+for (int x = 0; x < full_width; ++x)
-if ( full_width > 0 )
+{
-{
+if ( *pTexturea != Color16(0, 0xFFu, 0xFFu) )
-v23 = full_width;
+{
-do
+WritePixel16(pX + x, pY + y, *pTexturea);
-{
+/*if (FORCE_16_BITS)
-if ( *pTexturea != TargetColor(0, 0xFFu, 0xFFu) )
+*(unsigned __int16 *)v7 = *pTexturea;
-*v7 = *pTexturea;
+else
+*(unsigned __int32 *)v7 = r5g6b5_2_r8g8b8(*pTexturea);*/
+}
 ++pTexturea;
-++v7;
+//++v7;
---v23;
-}
-while ( v23 );
 }
-v7 += this->uTargetSurfacePitch - full_width;
+//v7 += this->uTargetSurfacePitch - full_width;
 pTexturea = (unsigned __int16 *)((char *)pTexturea + 2 * (pTexture->uWidth - full_width));
---full_height;
+}
-}
-while ( full_height );
-}
 }
 }
 //----- (004A6E7E) --------------------------------------------------------
 void Render::_4A6E7E(unsigned int a2, unsigned int a3, Texture *a4)
 {
-unsigned __int16 *v4; // eax@4
+//unsigned __int16 *v4; // eax@4
 int v5; // edx@4
 unsigned int v6; // edi@4
 unsigned int v7; // edx@5
 unsigned int v8; // edx@6
 unsigned int v9; // edx@7
 unsigned int v23; // [sp+2Ch] [bp+Ch]@23
 unsigned int v24; // [sp+2Ch] [bp+Ch]@32
 if ( this->uNumSceneBegins && a4 && a4->pPalette16 )
 {
-v4 = &this->pTargetSurface[a2 + a3 * this->uTargetSurfacePitch];
+//v4 = &this->pTargetSurface[a2 + a3 * this->uTargetSurfacePitch];
 v20 = a4->pLevelOfDetail0_prolly_alpha_mask;
 v5 = a4->uTextureWidth;
 v6 = a4->uTextureHeight;
 v19 = a4->uTextureWidth;
 v18 = a4->uTextureWidth;
+int clipped_out_x = a2;
+int clipped_out_y = a3;
 if ( this->bClip )
 {
 v7 = this->uClipX;
 if ( (signed int)a2 < (signed int)v7 )
 {
 v8 = v7 - a2;
 v20 += v8;
 v19 += a2 - this->uClipX;
-v4 += v8;
+//v4 += v8;
+clipped_out_x = uClipX;
 }
 v9 = this->uClipY;
 if ( (signed int)a3 < (signed int)v9 )
 {
 v10 = v9 - a3;
 v20 += v18 * v10;
 v6 = a3 - this->uClipY + a4->uTextureHeight;
-v4 += this->uTargetSurfacePitch * v10;
+//v4 += this->uTargetSurfacePitch * v10;
+clipped_out_y = uClipY;
 }
 v11 = this->uClipX;
 v5 = v19;
 if ( (signed int)v11 < (signed int)a2 )
 v11 = a2;
 if ( (signed int)v16 < (signed int)a3 )
 v16 = a3;
 v6 = v15 - v16;
 }
 }
-if ( pRenderer->uTargetGBits == 5 )
+for (int y = 0; y < v6; ++y)
+{
+for (int x = 0; x < v5; ++x)
+{
+if ( *v20 )
+WritePixel16(clipped_out_x + x, clipped_out_y + y, ((unsigned int)a4->pPalette16[*v20] >> 1) & 0x7BEF);
+++v20;
+}
+v20 += v18 - v5;
+}
+/*if ( pRenderer->uTargetGBits == 5 )
 {
 if ( (signed int)v6 > 0 )
 {
 v23 = v6;
 do
 v17 = v24-- == 1;
 v4 += this->uTargetSurfacePitch - v5;
 }
 while ( !v17 );
 }
-}
+}*/
 }
 }
 //----- (004A6DF5) --------------------------------------------------------
-int Render::_4A6DF5(unsigned __int16 *pBitmap, unsigned int uBitmapPitch, Vec2_int_ *pBitmapXY, unsigned __int16 *pTarget, unsigned int uTargetPitch, Vec4_int_ *a7)
+void Render::_4A6DF5(unsigned __int16 *pBitmap, unsigned int uBitmapPitch, Vec2_int_ *pBitmapXY, void *pTarget, unsigned int uTargetPitch, Vec4_int_ *a7)
 {
 int result; // eax@0
 int v8; // ecx@3
 unsigned __int16 *v9; // edi@4
 unsigned __int16 *v10; // ebx@4
 int v11; // esi@4
 unsigned __int16 *pBitmapa; // [sp+14h] [bp+8h]@3
 unsigned __int16 *pTargeta; // [sp+20h] [bp+14h]@3
-if ( pBitmap )
+if ( !pBitmap || !pTarget)
-{
+return;
-if ( pTarget )
-{
 pBitmapa = &pBitmap[pBitmapXY->x + uBitmapPitch * pBitmapXY->y];
-pTargeta = &pTarget[a7->x + uTargetPitch * a7->y];
+__debugbreak(); // sub expects 16bit target surface, we may have 32bit
+pTargeta = (unsigned short *)pTarget + a7->x + uTargetPitch * a7->y;
 v8 = a7->z - a7->x;
-result = a7->w - a7->y;
+v11 = a7->w - a7->y;
-if ( result > 0 )
+if ( v11 > 0 )
 {
 v9 = pBitmapa;
 v10 = pTargeta;
-v11 = a7->w - a7->y;
 do
 {
 if ( v8 > 0 )
 {
 result = v8;
 v10 += uTargetPitch - v8;
 --v11;
 }
 while ( v11 );
 }
-}
-}
-return result;
 }
 //----- (004A6D87) --------------------------------------------------------
 void Render::FillRectFast(unsigned int uX, unsigned int uY, unsigned int uWidth, unsigned int uHeight, unsigned int uColor16)
 {
 return;
 unsigned __int32 twoColors = (uColor16 << 16) | uColor16;
 for (uint y = 0; y < uHeight; ++y)
 {
-ushort* pDst = &pTargetSurface[uX + (y + uY) * uTargetSurfacePitch];
+void *pDst = (char *)pTargetSurface + (FORCE_16_BITS ? 2 : 4) * (uX + (y + uY) * uTargetSurfacePitch);
-memset32(pDst, twoColors, uWidth / 2);
+memset32(pDst,
-if (uWidth & 1)
+FORCE_16_BITS ? twoColors : Color32(uColor16),  // two colors per int (16bit) or 1 (32bit)
-pDst[uWidth - 1] = uColor16;
+uWidth / (FORCE_16_BITS ? 2 : 1));                      // two pixels per int (16bit) or 1 (32bit)
+if (FORCE_16_BITS && uWidth & 1) // we may miss one pixel for 16bit
+((unsigned __int16 *)pTargetSurface)[uX + uWidth - 1 + (y + uY) * uTargetSurfacePitch] = uColor16;
 }
 }
 //----- (004A6C4F) --------------------------------------------------------
 void Render::DrawText(signed int uOutX, signed int uOutY, unsigned __int8 *pFontPixels, unsigned int uCharWidth, unsigned int uCharHeight, unsigned __int16 *pFontPalette, unsigned __int16 uFaceColor, unsigned __int16 uShadowColor)
 {
 unsigned int v9; // edi@2
 unsigned int v10; // esi@2
-unsigned __int16 *v11; // eax@2
+//unsigned __int16 *v11; // eax@2
 unsigned int v12; // ebx@3
 signed int v13; // edx@5
 int v14; // edx@6
 signed int v15; // ebx@7
 unsigned int v16; // edx@9
 signed int v17; // edi@10
 signed int v18; // ebx@13
 unsigned int v19; // edx@15
 signed int v20; // esi@16
-unsigned int v21; // esi@22
+//unsigned int v21; // esi@22
 unsigned __int16 v22; // dx@24
-char v23; // zf@28
+//char v23; // zf@28
 unsigned __int8 *v24; // [sp+Ch] [bp-4h]@2
-unsigned int uOutXa; // [sp+18h] [bp+8h]@20
+//unsigned int uOutXa; // [sp+18h] [bp+8h]@20
-if ( this->uNumSceneBegins )
+if (!this->uNumSceneBegins)
-{
+return;
 v9 = uCharWidth;
 v10 = uCharHeight;
-v11 = &this->pTargetSurface[uOutX + uOutY * this->uTargetSurfacePitch];
+//v11 = &this->pTargetSurface[uOutX + uOutY * this->uTargetSurfacePitch];
 v24 = pFontPixels;
+int clipped_out_x = uOutX, clipped_out_y = uOutY;
 if ( this->bClip )
 {
 v12 = this->uClipX;
 if ( uOutX < (signed int)v12 )
 {
 v24 = &pFontPixels[v12 - uOutX];
-v11 += v12 - uOutX;
+//v11 += v12 - uOutX;
+clipped_out_x = uClipX;
 v9 = uCharWidth + uOutX - v12;
 }
 v13 = this->uClipY;
 if ( uOutY < v13 )
 {
 v14 = v13 - uOutY;
 v24 += uCharWidth * v14;
 v10 = uCharHeight + uOutY - this->uClipY;
-v11 += this->uTargetSurfacePitch * v14;
+//v11 += this->uTargetSurfacePitch * v14;
+clipped_out_y = uClipY;
 }
 v15 = this->uClipX;
 if ( v15 < uOutX )
 v15 = uOutX;
 v16 = this->uClipZ;
 if ( v20 < uOutY )
 v20 = uOutY;
 v10 = v19 - v20;
 }
 }
-if ( (signed int)v10 > 0 )
-{
+for (int y = 0; y < v10; ++y)
-uOutXa = v10;
+{
-do
+for (int x = 0; x < v9; ++x)
 {
-if ( (signed int)v9 > 0 )
+if (*v24)
 {
-v21 = v9;
+v22 = uShadowColor;
-do
+if ( *v24 != 1 )
-{
+v22 = uFaceColor;
-if ( *v24 )
+WritePixel16(clipped_out_x + x, clipped_out_y + y, v22);
-{
-v22 = uShadowColor;
-if ( *v24 != 1 )
-v22 = uFaceColor;
-*v11 = v22;
-}
-++v11;
-++v24;
---v21;
-}
-while ( v21 );
 }
+}
 v24 += uCharWidth - v9;
-v23 = uOutXa-- == 1;
+//v23 = uOutXa-- == 1;
-v11 += this->uTargetSurfacePitch - v9;
+//v11 += this->uTargetSurfacePitch - v9;
 }
-while ( !v23 );
-}
-}
 }
 //----- (004A6A68) --------------------------------------------------------
 void Render::GetLeather(unsigned int a2, unsigned int a3, Texture *a4, __int16 height)
 {
 //----- (004A6AB1) --------------------------------------------------------
 void Render::DrawTextPalette( int x, int y, unsigned char* font_pixels, int a5, unsigned int uFontHeight, unsigned __int16 *pPalette, int a8 )
 {
 int v8; // edi@2
 unsigned int v9; // esi@2
-unsigned __int16 *v10; // eax@2
+//unsigned __int16 *v10; // eax@2
 unsigned char *v11; // edx@2
 unsigned int v12; // ebx@3
 signed int v13; // edx@5
 int v14; // edx@6
 signed int v15; // ebx@7
 unsigned int v30; // [sp+24h] [bp+14h]@31
 int a2 = x;
 int a3 = y;
 uint a6 = uFontHeight;
-if ( this->uNumSceneBegins )
+if (!this->uNumSceneBegins)
-{
+return;
 v8 = a5;
 v9 = a6;
-v10 = &pTargetSurface[x + y * uTargetSurfacePitch];
+//v10 = &pTargetSurface[x + y * uTargetSurfacePitch];
 v11 = (unsigned char *)font_pixels;
 v25 = (int)font_pixels;
+int clipped_out_x = x;
+int clipped_out_y = y;
 if ( this->bClip )
 {
 v12 = this->uClipX;
 if ( a2 < (signed int)v12 )
 {
 v25 = v12 - a2 + (int)font_pixels;
-v10 += v12 - a2;
+//v10 += v12 - a2;
 v8 = a5 + a2 - v12;
+clipped_out_x = uClipX;
 }
 v13 = this->uClipY;
 if ( a3 < v13 )
 {
 v14 = v13 - a3;
 v25 += a5 * v14;
 v9 = a6 + a3 - this->uClipY;
-v10 += this->uTargetSurfacePitch * v14;
+//v10 += this->uTargetSurfacePitch * v14;
+clipped_out_y = uClipY;
 }
 v15 = this->uClipX;
 if ( v15 < a2 )
 v15 = a2;
 v16 = this->uClipZ;
 v20 = a3;
 v9 = v19 - v20;
 }
 v11 = (unsigned char *)v25;
 }
 if ( a8 )
 {
-v28 = pRenderer->uTargetGMask | pRenderer->uTargetBMask;
+v28 = 0x7FF; // 16bit pRenderer->uTargetGMask | pRenderer->uTargetBMask;
-if ( (signed int)v9 > 0 )
+for (int dy = 0; dy < v9; ++dy)
+{
+for (int dx = 0; dx < v8; ++dx)
+{
+if ( *v11 )
+v24 = pPalette[*v11];
+else
+v24 = v28;
+WritePixel16(clipped_out_x + dx, clipped_out_y + dy, v24);
+//*v10 = v24;
+//++v10;
+//++v11;
+//--v27;
+}
+v11 += a5 - v8;
+}
+/*if ( (signed int)v9 > 0 )
 {
 v23 = a5;
 v30 = v9;
 do
 {
 v11 += v23 - v8;
 v22 = v30-- == 1;
 v10 += this->uTargetSurfacePitch - v8;
 }
 while ( !v22 );
-}
+}*/
 }
 else
 {
-if ( (signed int)v9 > 0 )
+for (int dy = 0; dy < v9; ++dy)
+{
+for (int dx = 0; dx < v8; ++dx)
+{
+WritePixel16(clipped_out_x + dx, clipped_out_y + dy, pPalette[*v11]);
+//*v10 = v24;
+//++v10;
+//++v11;
+//--v27;
+}
+v11 += a5 - v8;
+}
+/*if ( (signed int)v9 > 0 )
 {
 v21 = a5;
 v29 = v9;
 do
 {
 v11 += v21 - v8;
 v22 = v29-- == 1;
 v10 += this->uTargetSurfacePitch - v8;
 }
 while ( !v22 );
-}
+}*/
 }
-}
 }
 //----- (004A68EF) --------------------------------------------------------
 void Render::DrawTransparentGreenShade(signed int a2, signed int a3, Texture *pTexture)
 {
-Texture *v4; // edi@2
+DrawMasked(a2, a3, pTexture, 0x07E0);
-unsigned int v5; // ebx@4
+}
-unsigned __int16 *v6; // eax@4
-signed int v7; // edx@5
-int v8; // edx@6
-signed int v9; // edx@7
-int v10; // edx@8
-signed int v11; // edx@9
-signed int v12; // esi@12
-signed int v13; // esi@15
-unsigned int v14; // edx@17
-signed int v15; // esi@18
-unsigned __int8 *v16; // ebx@22
-char v17; // zf@28
-int v18; // [sp+10h] [bp-10h]@4
-unsigned __int8 *v19; // [sp+18h] [bp-8h]@4
-int v20; // [sp+1Ch] [bp-4h]@4
-int v21; // [sp+28h] [bp+8h]@24
-unsigned int v22; // [sp+2Ch] [bp+Ch]@22
-unsigned int pTexturea; // [sp+30h] [bp+10h]@11
-if ( this->uNumSceneBegins )
-{
-v4 = pTexture;
-if ( pTexture )
-{
-if ( pTexture->pPalette16 )
-{
-v5 = pTexture->uTextureHeight;
-v6 = &this->pTargetSurface[a2 + a3 * this->uTargetSurfacePitch];
-v19 = pTexture->pLevelOfDetail0_prolly_alpha_mask;
-v20 = pTexture->uTextureWidth;
-v18 = pTexture->uTextureWidth;
-if ( this->bClip )
-{
-v7 = this->uClipX;
-if ( a2 < v7 )
-{
-v8 = v7 - a2;
-v19 += v8;
-v20 += a2 - this->uClipX;
-v6 += v8;
-}
-v9 = this->uClipY;
-v5 = pTexture->uTextureHeight;
-if ( a3 < v9 )
-{
-v10 = v9 - a3;
-v19 += v18 * v10;
-v5 = a3 - this->uClipY + pTexture->uTextureHeight;
-v4 = pTexture;
-v6 += this->uTargetSurfacePitch * v10;
-}
-v11 = this->uClipX;
-if ( v11 < a2 )
-v11 = a2;
-pTexturea = this->uClipZ;
-if ( v11 + v20 > (signed int)pTexturea )
-{
-v12 = this->uClipX;
-if ( v12 < a2 )
-v12 = a2;
-v20 = pTexturea - v12;
-}
-v13 = this->uClipY;
-if ( v13 < a3 )
-v13 = a3;
-v14 = this->uClipW;
-if ( (signed int)(v5 + v13) > (signed int)v14 )
-{
-v15 = this->uClipY;
-if ( v15 < a3 )
-v15 = a3;
-v5 = v14 - v15;
-}
-}
-if ( (signed int)v5 > 0 )
-{
-v22 = v5;
-v16 = v19;
-do
-{
-if ( v20 > 0 )
-{
-v21 = v20;
-do
-{
-if ( *v16 )
-*v6 = this->uTargetGMask & v4->pPalette16[*v16];
-++v6;
-++v16;
---v21;
-}
-while ( v21 );
-}
-v16 += v18 - v20;
-v17 = v22-- == 1;
-v6 += this->uTargetSurfacePitch - v20;
-}
-while ( !v17 );
-}
-}
-}
-}
-}
 //----- (004A6776) --------------------------------------------------------
 void Render::DrawTransparentRedShade(unsigned int a2, unsigned int a3, Texture *a4)
 {
-Texture *v4; // edi@2
+DrawMasked(a2, a3, a4, 0xF800);
+/*Texture *v4; // edi@2
 unsigned int v5; // ebx@4
 unsigned __int16 *v6; // eax@4
 unsigned int v7; // edx@5
 unsigned int v8; // edx@6
 unsigned int v9; // edx@7
 }
 while ( !v17 );
 }
 }
 }
-}
+}*/
 }
+//----- (004A68EF) --------------------------------------------------------
+void Render::DrawMasked(signed int a2, signed int a3, Texture *pTexture, unsigned __int16 mask)
+{
+Texture *v4; // edi@2
+unsigned int v5; // ebx@4
+//unsigned __int16 *v6; // eax@4
+signed int v7; // edx@5
+int v8; // edx@6
+signed int v9; // edx@7
+int v10; // edx@8
+signed int v11; // edx@9
+signed int v12; // esi@12
+signed int v13; // esi@15
+unsigned int v14; // edx@17
+signed int v15; // esi@18
+unsigned __int8 *v16; // ebx@22
+char v17; // zf@28
+int v18; // [sp+10h] [bp-10h]@4
+unsigned __int8 *v19; // [sp+18h] [bp-8h]@4
+int v20; // [sp+1Ch] [bp-4h]@4
+int v21; // [sp+28h] [bp+8h]@24
+unsigned int v22; // [sp+2Ch] [bp+Ch]@22
+unsigned int pTexturea; // [sp+30h] [bp+10h]@11
+if (!uNumSceneBegins || !pTexture)
+return;
+v4 = pTexture;
+if ( pTexture->pPalette16 )
+{
+v5 = pTexture->uTextureHeight;
+//v6 = &this->pTargetSurface[a2 + a3 * this->uTargetSurfacePitch];
+v19 = pTexture->pLevelOfDetail0_prolly_alpha_mask;
+v20 = pTexture->uTextureWidth;
+v18 = pTexture->uTextureWidth;
+int clipped_out_x = a2;
+int clipped_out_y = a3;
+if ( this->bClip )
+{
+v7 = this->uClipX;
+if ( a2 < v7 )
+{
+v8 = v7 - a2;
+v19 += v8;
+v20 += a2 - this->uClipX;
+//v6 += v8;
+clipped_out_x = uClipX;
+}
+v9 = this->uClipY;
+v5 = pTexture->uTextureHeight;
+if ( a3 < v9 )
+{
+v10 = v9 - a3;
+v19 += v18 * v10;
+v5 = a3 - this->uClipY + pTexture->uTextureHeight;
+v4 = pTexture;
+//v6 += this->uTargetSurfacePitch * v10;
+clipped_out_y = uClipY;
+}
+v11 = this->uClipX;
+if ( v11 < a2 )
+v11 = a2;
+pTexturea = this->uClipZ;
+if ( v11 + v20 > (signed int)pTexturea )
+{
+v12 = this->uClipX;
+if ( v12 < a2 )
+v12 = a2;
+v20 = pTexturea - v12;
+}
+v13 = this->uClipY;
+if ( v13 < a3 )
+v13 = a3;
+v14 = this->uClipW;
+if ( (signed int)(v5 + v13) > (signed int)v14 )
+{
+v15 = this->uClipY;
+if ( v15 < a3 )
+v15 = a3;
+v5 = v14 - v15;
+}
+}
+v16 = v19;
+for (int y = 0; y < v5; ++y)
+{
+for (int x = 0; x < v20; ++x)
+{
+if ( *v16 )
+WritePixel16(clipped_out_x + x, clipped_out_y + y, v4->pPalette16[*v16] & mask);
+++v16;
+}
+v16 += v18 - v20;
+}
+/*if ( (signed int)v5 > 0 )
+{
+v22 = v5;
+v16 = v19;
+do
+{
+if ( v20 > 0 )
+{
+v21 = v20;
+do
+{
+if ( *v16 )
+*v6 = this->uTargetGMask & v4->pPalette16[*v16];
+++v6;
+++v16;
+--v21;
+}
+while ( v21 );
+}
+v16 += v18 - v20;
+v17 = v22-- == 1;
+v6 += this->uTargetSurfacePitch - v20;
+}
+while ( !v17 );
+}*/
+}
+}
 //----- (004A65CC) --------------------------------------------------------
 void Render::_4A65CC(unsigned int x, unsigned int y, Texture *a4, Texture *a5, int a6, int a7, int a8)
 {
-unsigned __int16 *v8; // esi@6
+//unsigned __int16 *v8; // esi@6
 unsigned int v9; // edi@6
 unsigned int v10; // eax@7
 unsigned int v11; // eax@8
 unsigned int v12; // eax@9
 unsigned int v13; // eax@10
 unsigned int ya; // [sp+24h] [bp+Ch]@24
 int v27; // [sp+2Ch] [bp+14h]@6
 if ( this->uNumSceneBegins && a4 && a4->pPalette16 && a5 && a5->pPalette16 )
 {
-v8 = &this->pTargetSurface[x + y * this->uTargetSurfacePitch];
+//v8 = &this->pTargetSurface[x + y * this->uTargetSurfacePitch];
 v24 = a4->pLevelOfDetail0_prolly_alpha_mask;
 v27 = a4->uTextureWidth;
 v9 = a4->uTextureHeight;
 v22 = a4->uTextureWidth;
+int clipped_out_x = x;
+int clipped_out_y = y;
 if ( this->bClip )
 {
 v10 = this->uClipX;
 if ( (signed int)x < (signed int)v10 )
 {
 v11 = v10 - x;
 v24 += v11;
 v27 += x - this->uClipX;
-v8 += v11;
+//v8 += v11;
+clipped_out_x = uClipX;
 }
 v12 = this->uClipY;
 if ( (signed int)y < (signed int)v12 )
 {
 v13 = v12 - y;
 v24 += v22 * v13;
 v9 = y - this->uClipY + a4->uTextureHeight;
-v8 += this->uTargetSurfacePitch * v13;
+//v8 += this->uTargetSurfacePitch * v13;
+clipped_out_y = uClipY;
 }
 v14 = this->uClipX;
 if ( (signed int)v14 < (signed int)x )
 v14 = x;
 v15 = this->uClipZ;
 if ( (signed int)v19 < (signed int)y )
 v19 = y;
 v9 = v18 - v19;
 }
 }
-if ( (signed int)v9 > 0 )
+for (int dy = 0; dy < v9; ++dy)
+{
+for (int dx = 0; dx < v27; ++dx)
+{
+v20 = *v24;
+if ( v20 >= a7 && v20 <= a8 )
+{
+v21 = a7 + (a6 + v20) % (2 * (a8 - a7));
+if ( (a6 + v20) % (2 * (a8 - a7)) >= a8 - a7 )
+v21 = 2 * a8 - v21 - a7;
+//*v8 = a4->pPalette16[v21];
+WritePixel16(clipped_out_x + dx, clipped_out_y + dy, a4->pPalette16[v21]);
+}
+++v24;
+}
+v24 += v22 - v27;
+}
+/*if ( (signed int)v9 > 0 )
 {
 ya = v9;
 v23 = v22 - v27;
 do
 {
 v8 += this->uTargetSurfacePitch - v27;
 v24 += v23;
 --ya;
 }
 while ( ya );
-}
+}*/
 }
 }
 //----- (004A63E6) --------------------------------------------------------
 void Render::DrawAura(unsigned int a2, unsigned int a3, Texture *a4, Texture *a5, int a6, int a7, int a8)
 {
 Texture *v8; // eax@2
-Texture *v9; // ebx@4
+//Texture *v9; // ebx@4
-unsigned __int16 *v10; // esi@6
+//unsigned __int16 *v10; // esi@6
 unsigned int v11; // edi@7
 unsigned int v12; // eax@9
 unsigned int v13; // eax@10
 unsigned int v14; // edx@11
 unsigned int v15; // eax@13
 v8 = a4;
 if ( a4 )
 {
 if ( a4->pPalette16 )
 {
-v9 = a5;
 if ( a5 )
 {
 if ( a5->pPalette16 )
 {
-v10 = &this->pTargetSurface[a2 + a3 * this->uTargetSurfacePitch];
+//v10 = &this->pTargetSurface[a2 + a3 * this->uTargetSurfacePitch];
 v28 = a4->pLevelOfDetail0_prolly_alpha_mask;
 v25 = v8->uTextureWidth;
 v24 = v8->uTextureHeight;
 v22 = v8->uTextureWidth;
+int clipped_out_x = a2;
+int clipped_out_y = a3;
 if ( this->bClip )
 {
 v11 = this->uClipX;
 if ( (signed int)a2 < (signed int)v11 )
 {
 v28 += v11 - a2;
 v25 += a2 - v11;
-v9 = a5;
+//v10 += v11 - a2;
-v10 += v11 - a2;
+clipped_out_x = uClipX;
 }
 v12 = this->uClipY;
 if ( (signed int)a3 < (signed int)v12 )
 {
 v13 = v12 - a3;
-v9 = a5;
 v28 += v22 * v13;
 v24 += a3 - this->uClipY;
-v10 += this->uTargetSurfacePitch * v13;
+//v10 += this->uTargetSurfacePitch * v13;
+clipped_out_y = uClipY;
 }
 v14 = this->uClipX;
 if ( (signed int)v14 < (signed int)a2 )
 v14 = a2;
 v15 = this->uClipZ;
 if ( (signed int)v19 < (signed int)a3 )
 v19 = a3;
 v24 = v18 - v19;
 }
 }
 v27 = 0;
-if ( v24 > 0 )
+for (int y = 0; y < v24; ++y)
+{
+for (int x = 0; x < v25; ++x)
+{
+if ( *v28 )
+{
+v20 = *(&a5->pLevelOfDetail0_prolly_alpha_mask[i & a5->uWidthMinus1] + a5->uTextureWidth * (v27 & a5->uHeightMinus1));
+if ( v20 >= a7 )
+{
+if ( v20 <= a8 )
+{
+v21 = a7 + (a6 + v20) % (2 * (a8 - a7));
+if ( (a6 + v20) % (2 * (a8 - a7)) >= a8 - a7 )
+v21 = 2 * a8 - v21 - a7;
+//v9 = a5;
+//*v10 = a5->pPalette16[v21];
+WritePixel16(clipped_out_x + x, clipped_out_y + y, a5->pPalette16[v21]);
+}
+}
+}
+v28++;
+}
+v28 += v22 - v25;
+}
+/*if ( v24 > 0 )
 {
 v23 = v22 - v25;
 do
 {
 for ( i = 0; i < v25; ++v28 )
 ++v27;
 v10 += this->uTargetSurfacePitch - v25;
 v28 += v23;
 }
 while ( v27 < v24 );
-}
+}*/
 }
 }
 }
 }
 }
 //----- (004A6274) --------------------------------------------------------
 void Render::DrawTextureTransparent(unsigned int uX, unsigned int uY, Texture *pTexture)
 {
 Texture *pCurrentTexture; // edi@2
 int uHeight; // ebx@4
-unsigned __int16 *v6; // eax@4
+//unsigned __int16 *v6; // eax@4
 unsigned int v7; // edx@5
 unsigned int v8; // edx@6
 unsigned int v9; // edx@7
 unsigned int v10; // edx@8
 unsigned int v11; // edx@9
 if ( pTexture )
 {
 if ( pTexture->pPalette16 )
 {
 uHeight = pTexture->uTextureHeight;
-v6 = &this->pTargetSurface[uX + uY * this->uTargetSurfacePitch];
+//v6 = &this->pTargetSurface[uX + uY * this->uTargetSurfacePitch];
 v19 = pTexture->pLevelOfDetail0_prolly_alpha_mask;
 uWidth = pTexture->uTextureWidth;
 v18 = pTexture->uTextureWidth;
+int clipped_out_x = uX;
+int clipped_out_y = uY;
 if ( this->bClip )
 {
 v7 = this->uClipX;
 if ( (signed int)uX < (signed int)v7 )
 {
 v8 = v7 - uX;
 v19 += v8;
 uWidth += uX - this->uClipX;
-v6 += v8;
+//v6 += v8;
+clipped_out_x = uClipX;
 }
 v9 = this->uClipY;
 uHeight = pTexture->uTextureHeight;
 if ( (signed int)uY < (signed int)v9 )
 {
 v10 = v9 - uY;
 v19 += v18 * v10;
 uHeight = uY - this->uClipY + pTexture->uTextureHeight;
 pCurrentTexture = pTexture;
-v6 += this->uTargetSurfacePitch * v10;
+//v6 += this->uTargetSurfacePitch * v10;
+clipped_out_y = uClipY;
 }
 v11 = this->uClipX;
 if ( (signed int)v11 < (signed int)uX )
 v11 = uX;
 pTexturea = this->uClipZ;
 if ( (signed int)v15 < (signed int)uY )
 v15 = uY;
 uHeight = v14 - v15;
 }
 }
-if ( (signed int)uHeight > 0 )
+v16 = v19;
+for (int y = 0; y < uHeight; ++y)
+{
+for (int x = 0; x < uWidth; ++x)
+{
+if ( *v16 )
+WritePixel16(clipped_out_x + x, clipped_out_y + y, pCurrentTexture->pPalette16[*v16]);
+++v16;
+}
+v16 += v18 - uWidth;
+}
+/*if ( (signed int)uHeight > 0 )
 {
 uYa = uHeight;
 v16 = v19;
 do
 {
 v16 += v18 - uWidth;
 uFlag = uYa-- == 1;
 v6 += this->uTargetSurfacePitch - uWidth;
 }
 while ( !uFlag );
-}
+}*/
 }
 }
 }
 }
 //----- (004A5EB2) --------------------------------------------------------
 void Render::DrawTextureIndexed(unsigned int uX, unsigned int uY, Texture *a4)
 {
 Texture *v4; // edi@2
-unsigned int v5; // ebx@4
+int v5; // ebx@4
-unsigned __int16 *pTarget; // eax@4
+//unsigned __int16 *pTarget; // eax@4
 unsigned int v7; // edx@5
 unsigned int v8; // edx@6
 unsigned int v9; // edx@7
 unsigned int v10; // edx@8
 unsigned int v11; // edx@9
 unsigned int v12; // esi@12
 unsigned int v13; // esi@15
-unsigned int v14; // edx@17
+//unsigned int v14; // edx@17
 unsigned int v15; // esi@18
 unsigned __int8 *v16; // edx@22
 char v17; // zf@26
 int v18; // [sp+10h] [bp-10h]@4
 unsigned __int8 *v19; // [sp+18h] [bp-8h]@4
 if ( a4 )
 {
 if ( a4->pPalette16 )
 {
 v5 = a4->uTextureHeight;
-pTarget = &this->pTargetSurface[uX + uY * this->uTargetSurfacePitch];
+//pTarget = &this->pTargetSurface[uX + uY * this->uTargetSurfacePitch];
 v19 = a4->pLevelOfDetail0_prolly_alpha_mask;
 v20 = a4->uTextureWidth;
 v18 = a4->uTextureWidth;
+int clipped_out_x = uX;
+int clipped_out_y = uY;
 if ( this->bClip )
 {
 v7 = this->uClipX;
 if ( (signed int)uX < (signed int)v7 )
 {
 v8 = v7 - uX;
 v19 += v8;
 v20 += uX - this->uClipX;
-pTarget += v8;
+//pTarget += v8;
+clipped_out_x = uClipX;
 }
 v9 = this->uClipY;
 v5 = a4->uTextureHeight;
 if ( (signed int)uY < (signed int)v9 )
 {
 v10 = v9 - uY;
 v19 += v18 * v10;
 v5 = uY - this->uClipY + a4->uTextureHeight;
 v4 = a4;
-pTarget += this->uTargetSurfacePitch * v10;
+//pTarget += this->uTargetSurfacePitch * v10;
+clipped_out_y = uClipY;
 }
 v11 = this->uClipX;
 if ( (signed int)v11 < (signed int)uX )
 v11 = uX;
 v23 = this->uClipZ;
 v20 = v23 - v12;
 }
 v13 = this->uClipY;
 if ( (signed int)v13 < (signed int)uY )
 v13 = uY;
-v14 = this->uClipW;
-if ( (signed int)(v5 + v13) > (signed int)v14 )
+if ( (signed int)(v5 + v13) > (signed int)uClipW )
 {
 v15 = this->uClipY;
 if ( (signed int)v15 < (signed int)uY )
 v15 = uY;
-v5 = v14 - v15;
+v5 = uClipW - v15;
 }
 }
-if ( (signed int)v5 > 0 )
+v16 = v19;
+for (int y = 0; y < v5; ++y)
+{
+for (int x = 0; x < v20; ++x)
+{
+WritePixel16(clipped_out_x + x, clipped_out_y + y, v4->pPalette16[*v16]);
+++v16;
+}
+v16 += v18 - v20;
+}
+/*if ( (signed int)v5 > 0 )
 {
 uYa = v5;
 v16 = v19;
 do
 {
 v16 += v18 - v20;
 v17 = uYa-- == 1;
 pTarget += this->uTargetSurfacePitch - v20;
 }
 while ( !v17 );
-}
+}*/
 }
 }
 }
 }

Mercurial > mm7

comparison Render.cpp @ 2069:259df09dfb50