Mercurial > mm7
diff Render.cpp @ 0:9c0607679772
init
| author | Ritor1 |
|---|---|
| date | Sat, 12 Jan 2013 09:45:18 +0600 |
| parents | |
| children | 8e33efd39355 |
line wrap: on
line diff
--- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/Render.cpp Sat Jan 12 09:45:18 2013 +0600 @@ -0,0 +1,11160 @@ +#include "Render.h" +#include "OutdoorCamera.h" +#include "IndoorCamera.h" +#include "Outdoor.h" +#include "Party.h" +#include "LOD.h" +#include "Viewport.h" +#include "Math.h" +#include "PaletteManager.h" +#include "Time.h" +#include "Game.h" +#include "LightmapBuilder.h" +#include "stru220.h" +#include "ObjectList.h" +#include "LayingItem.h" +#include "DecorationList.h" +#include "Allocator.h" +#include "OSInfo.h" +#include "Log.h" + +#include "mm7_data.h" + + +#pragma comment(lib, "lib\\legacy_dx\\lib\\ddraw.lib") +#pragma comment(lib, "lib\\legacy_dx\\lib\\dxguid.lib") + + + + + + + +struct IDirectDrawClipper *pDDrawClipper; +struct Render *pRenderer; // idb + + +int uNumDecorationsDrawnThisFrame; // weak +RenderBillboard pBillboardRenderList[500]; +unsigned int uNumBillboardsToDraw; +int uNumSpritesDrawnThisFrame; // weak + + +RenderVertexSoft array_507D30[50]; +RenderVertexSoft array_508690[50]; +RenderVertexSoft array_508FF0[50]; +RenderVertexSoft array_509950[50]; +RenderVertexSoft array_50A2B0[50]; +RenderVertexSoft array_50AC10[50]; + +RenderVertexSoft array_73D150[20]; + +RenderVertexD3D3 arary_77E5C8[50]; + +RenderVertexSoft *ptr_801A04; +RenderVertexSoft *ptr_801A08; + +RenderVertexSoft pVerticesSR_801A10[384]; +RenderVertexSoft pVerticesSR_806210[384]; + + + + + + + +void SetBillboardBlendOptions(RenderBillboardD3D::OpacityType a1); + + +/* 384 */ +#pragma pack(push, 1) +struct PCXHeader_1 +{ + char manufacturer; + char version; + char encoding; + char bpp; + __int16 left; + __int16 up; + __int16 right; + __int16 bottom; + __int16 hdpi; + __int16 vdpi; +}; +#pragma pack(pop) + +/* 385 */ +#pragma pack(push, 1) +struct PCXHeader_2 +{ + char reserved; + char planes; + __int16 pitch; + __int16 palette_info; +}; +#pragma pack(pop) + + + + + + + + +HRESULT __stdcall D3DZBufferFormatEnumerator(DDPIXELFORMAT *Src, DDPIXELFORMAT *Dst); +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 __cdecl 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 + IDirect3DTexture2 *pTexture2; // [sp+18h] [bp-8h]@1 + IDirect3DTexture2 *pTexture1; // [sp+1Ch] [bp-4h]@1 + + v0 = false; + pRenderer->pRenderD3D->CreateTexture(64u, 64u, &pSurface1, &pTexture1, true, false, 32u); + pRenderer->pRenderD3D->CreateTexture(64u, 64u, &pSurface2, &pTexture2, true, false, 32u); + + ErrD3D(pRenderer->pRenderD3D->pDevice->SetTexture(0, pTexture1)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_ADDRESS, 1u)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_COLOROP, 2u)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_COLORARG1, 2u)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_MAGFILTER, 2u)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_MINFILTER, 2u)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_MIPFILTER, 1u)); + + ErrD3D(pRenderer->pRenderD3D->pDevice->SetTexture(0, pTexture2)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetTextureStageState(1, D3DTSS_ADDRESS, 3u)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetTextureStageState(1, D3DTSS_TEXCOORDINDEX, 1u)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetTextureStageState(1, D3DTSS_COLOROP, 7u)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetTextureStageState(1, D3DTSS_COLORARG1, 2u)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetTextureStageState(1, D3DTSS_COLORARG2, 1u)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetTextureStageState(1, D3DTSS_MAGFILTER, 2u)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetTextureStageState(1, D3DTSS_MINFILTER, 2u)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetTextureStageState(1, D3DTSS_MIPFILTER, 1u)); + + if ( !pRenderer->pRenderD3D->pDevice->ValidateDevice(&v4) && v4 == 1 ) + v0 = true; + ErrD3D(pRenderer->pRenderD3D->pDevice->SetTextureStageState(1, D3DTSS_COLOROP, 1u)); + pTexture1->Release(); + pTexture2->Release(); + pSurface1->Release(); + pSurface2->Release(); + return v0; +} + + + + + + + + + + + + + +//----- (00440CB8) -------------------------------------------------------- +void Render::DrawBillboardList_BLV() +{ + __int16 v2; // ax@3 + int v5; // eax@11 + RenderBillboardTransform_local0 soft_billboard; // [sp+4h] [bp-50h]@1 + + soft_billboard.uParentBillboardID = -1; + soft_billboard.pTarget = pBLVRenderParams->pRenderTarget; + soft_billboard.pTargetZ = pBLVRenderParams->pTargetZBuffer; + soft_billboard.uTargetPitch = pRenderer->uTargetSurfacePitch; + soft_billboard.uViewportX = pBLVRenderParams->uViewportX; + soft_billboard.uViewportY = pBLVRenderParams->uViewportY; + soft_billboard.uViewportZ = pBLVRenderParams->uViewportZ - 1; + soft_billboard.uViewportW = pBLVRenderParams->uViewportW; + + pOutdoorCamera->uNumBillboards = uNumBillboardsToDraw; + + for (uint i = 0; i < uNumBillboardsToDraw; ++i) + { + auto p = pBillboardRenderList + i; + + soft_billboard.uScreenSpaceX = p->uScreenSpaceX; + soft_billboard.uParentBillboardID = i; + soft_billboard.uScreenSpaceY = p->uScreenSpaceY; + soft_billboard.field_10 = p->field_0; + soft_billboard.field_14 = p->field_4; + soft_billboard.sZValue = p->sZValue; + soft_billboard.uFlags = p->field_1E; + soft_billboard.uTintColor = p->uTintColor; + v2 = p->uHwSpriteID; + if ( v2 != -1 ) + { + if ( pRenderer->pRenderD3D ) + pRenderer->DrawBillboard_Indoor(&soft_billboard, &pSprites_LOD->pHardwareSprites[v2], p->uPaletteSubindex); + else + { + soft_billboard.pPalette = PaletteManager::Get_Dark_or_Red_LUT(p->uPalette, p->uPaletteSubindex, 1); + if (p->field_1E & 0x0100) + soft_billboard.pPalette = pPaletteManager->field_261600[p->uPalette]; + if ( !(soft_billboard.uFlags & 0x40) && soft_billboard.uFlags & 0x80 ) + soft_billboard.pPalette2 = PaletteManager::Get_Dark_or_Red_LUT(p->uPalette, 0, 1); + v5 = p->uHwSpriteID; + if ( v5 >= 0 ) + pSprites_LOD->pSpriteHeaders[v5]._4ACC38(&soft_billboard, 1); + } + } + } +} + + + + + +//----- (004A16A5) -------------------------------------------------------- +bool __cdecl AreRenderSurfacesOk() +{ + char v0; // zf@4 + bool result; // eax@8 + + if ( pVersion->pVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT || pVersion->pVersionInfo.dwMajorVersion != 4 ) + { + if ( !pRenderer->pBackBuffer4 ) + goto LABEL_9; + v0 = pRenderer->pFrontBuffer4 == 0; + } + else + { + if ( !pRenderer->pBackBuffer2 ) + goto LABEL_9; + v0 = pRenderer->pFrontBuffer2 == 0; + } + if ( !v0 ) + { + LOBYTE(result) = 1; + return result; + } +LABEL_9: + LOBYTE(result) = 0; + return result; +} + + + +//----- (00487389) -------------------------------------------------------- +__int16 Render::ExecOutdoorDrawSW() +{ + unsigned __int16 *v0; // ebx@1 + unsigned int v1; // esi@1 + stru148 *v2; // eax@1 + Span *v3; // edi@6 + stru148 *v4; // esi@9 + Texture *v5; // ebp@10 + int v6; // esi@16 + unsigned int v7; // edx@16 + char *v8; // ecx@17 + unsigned int v9; // edi@22 + int v10; // eax@26 + int v11; // eax@27 + unsigned int v12; // ebp@32 + Span *v13; // esi@33 + int v14; // ecx@37 + int v15; // eax@40 + Texture *v16; // ebp@51 + unsigned int v17; // eax@51 + int v18; // eax@54 + char v19; // al@56 + unsigned int v20; // eax@57 + int v21; // ecx@57 + unsigned int v22; // eax@57 + stru149 *v23; // eax@65 + int v24; // eax@67 + ODMFace *v25; // eax@78 + signed int v26; // edx@79 + signed int v27; // ecx@79 + unsigned int v28; // eax@106 + unsigned int v29; // ebp@117 + Span *v30; // esi@118 + unsigned int v31; // ST04_4@124 + int v33; // [sp+18h] [bp-44h]@80 + signed int v34; // [sp+1Ch] [bp-40h]@3 + signed int v35; // [sp+20h] [bp-3Ch]@79 + Span **v36; // [sp+24h] [bp-38h]@4 + unsigned int v37; // [sp+28h] [bp-34h]@1 + unsigned __int16 *a1; // [sp+2Ch] [bp-30h]@1 + int a1a; // [sp+2Ch] [bp-30h]@26 + unsigned int a1b; // [sp+2Ch] [bp-30h]@116 + char v41; // [sp+30h] [bp-2Ch]@57 + + v0 = pRenderer->pTargetSurface; + v1 = pOutdoorCamera->numStru148s; + a1 = pRenderer->pTargetSurface; + v2 = array_77EC08; + v37 = pOutdoorCamera->numStru148s; + if ( !(pParty->uFlags & 2) ) + { + v1 = uNumElementsIn80AA28; + v2 = ptr_80AA28[0]; + v37 = uNumElementsIn80AA28; + } + v34 = 0; + if ( (signed int)v1 > 0 ) + { + v36 = &v2->prolly_head; + do + { + if ( pParty->uFlags & 2 ) + v3 = *v36; + else + v3 = ptr_80AA28[v34]->prolly_head; + if ( v3 ) + { + v4 = v3->pParent; + if ( v4 ) + { + v5 = v4->pTexture; + if ( v5 ) + { + if ( v3->field_8 >= (signed int)pViewport->uViewportX || v3->field_C != pViewport->uViewportX ) + { + LOBYTE(v4->field_32) |= 2u; + v14 = *(int *)&v4->flags; + if ( v14 & 0x10 && v4->field_59 != 5 ) + { + dword_80AA20 = (v4->field_5C - 64) << 25; + dword_80AA1C = dword_80AA20 + 0x1FF0000; + dword_80AA14 = (v4->field_5D << 25) + 0x7FFF0000; + dword_80AA18 = dword_80AA14 - 0x1FF0000; + byte_80AA10 = ((unsigned int)pOutdoor->ActuallyGetSomeOtherTileInfo( + v4->field_5C, + v4->field_5D - 1) >> 9) & 1; + if ( *(int *)&v4->flags & 2 || (v15 = *(int *)&v4->flags, BYTE1(v15) & 1) ) + { + if ( *(int *)&v4->flags & 2 ) + { + while ( 1 ) + { + if ( pOutdoorCamera->outdoor_no_wavy_water ) + sr_sub_48408A_prolly_odm_water_no_waves(v3); + else + sr_sub_485407_prolly_odm_water_wavy(v3); + v3->field_E = LOWORD(unnamed_6BE060[1]); + if ( v4->prolly_tail == v3 ) + break; + v3 = v3->pNext; + } + } + else + { + while ( 1 ) + { + v16 = v4->pTexture; + v17 = pBitmaps_LOD->LoadTexture("wtrtyl"); + v4->pTexture = (Texture *)(v17 != -1 ? (int)&pBitmaps_LOD->pTextures[v17] : 0); + if ( pOutdoorCamera->outdoor_no_wavy_water ) + sr_sub_48408A_prolly_odm_water_no_waves(v3); + else + sr_sub_485407_prolly_odm_water_wavy(v3); + v18 = v4->field_5C - 64; + v4->pTexture = v16; + dword_80AA20 = v18 << 25; + dword_80AA1C = (v18 << 25) + 0x1FF0000; + dword_80AA14 = (v4->field_5D << 25) + 0x7FFF0000; + dword_80AA18 = dword_80AA14 - 0x1FF0000; + byte_80AA10 = ((unsigned int)pOutdoor->ActuallyGetSomeOtherTileInfo( + v4->field_5C, + v4->field_5D - 1) >> 9) & 1; + sr_sub_484442(v3); + v3->field_E = LOWORD(unnamed_6BE060[1]); + if ( v4->prolly_tail == v3 ) + break; + v3 = v3->pNext; + } + } + } + else + { + while ( sr_sub_48408A_prolly_odm_water_no_waves(v3) ) + { + v3->field_E = LOWORD(unnamed_6BE060[1]); + if ( v4->prolly_tail == v3 ) + break; + v3 = v3->pNext; + } + } + } + else + { + v19 = v4->field_59; + if ( v19 != 5 ) + { + if ( v14 & 2 ) + { + while ( 1 ) + { + v28 = pBitmaps_LOD->LoadTexture("wtrtyla"); + v4->pTexture = (Texture *)(v28 != -1 ? &pBitmaps_LOD->pTextures[v28] : 0); + if ( !sr_sub_4847EB(v3) ) + break; + v4->pTexture = v5; + if ( !sr_sub_484442(v3) ) + break; + v3->field_E = LOWORD(unnamed_6BE060[1]); + if ( v4->prolly_tail == v3 ) + break; + v3 = v3->pNext; + v5 = v4->pTexture; + } + } + else + { + if ( v19 == 1 ) + { + dword_80AA20 = (v4->field_5C - 64) << 25; + dword_80AA1C = dword_80AA20 + 33488896; + dword_80AA14 = (v4->field_5D << 25) + 0x7FFF0000; + dword_80AA18 = dword_80AA14 - 33488896; + byte_80AA10 = ((unsigned int)pOutdoor->ActuallyGetSomeOtherTileInfo( + v4->field_5C, + v4->field_5D - 1) >> 9) & 1; + while ( 1 ) + { + if ( !sr_sub_4847EB(v3) ) + sr_sub_48585C_mb_DrawSpan(v3, &pRenderer->pTargetSurface[v3->field_8 + 640 * v3->field_A], 0); + v3->field_E = LOWORD(unnamed_6BE060[1]); + if ( v4->prolly_tail == v3 ) + break; + v3 = v3->pNext; + } + } + } + goto LABEL_14; + } + v4->ptr_38 = (stru149 *)&v41; + v4->_479295(); + v20 = GetTickCount(); + v21 = *(int *)&v4->flags; + v22 = v20 >> 3; + if ( BYTE1(v21) & 4 ) + { + v4->sTextureDeltaV -= v22 & v4->pTexture->uHeightMinus1; + } + else + { + if ( BYTE1(v21) & 8 ) + v4->sTextureDeltaV += v22 & v4->pTexture->uHeightMinus1; + } + if ( BYTE1(v21) & 0x10 ) + { + v4->sTextureDeltaU -= v22 & v4->pTexture->uWidthMinus1; + } + else + { + if ( BYTE1(v21) & 0x20 ) + v4->sTextureDeltaU += v22 & v4->pTexture->uWidthMinus1; + } + v23 = v4->ptr_38; + v4->field_52 = 32; + v4->field_5A = 5; + if ( (double)abs(v23->field_C) > 52428.8 ) + { + v4->field_52 = 8; + v4->field_5A = 3; + } + v24 = *(int *)&v4->flags; + if ( !(v24 & 0x10000) ) + { + if ( !(v24 & 2) ) + { + v25 = v4->pODMFace; + if ( v25->uPolygonType == 1 ) + { + v26 = v25->pTextureUIDs[0]; + dword_80AA1C = v26; + dword_80AA20 = v26; + v27 = v25->pTextureVIDs[0]; + dword_80AA14 = v27; + dword_80AA18 = v27; + v35 = 1; + if ( v25->uNumVertices > 1u ) + { + v33 = (int)&v25->pTextureVIDs[1]; + do + { + if ( dword_80AA20 > *(short *)(v33 - 40) ) + dword_80AA20 = *(short *)(v33 - 40); + if ( v26 < *(short *)(v33 - 40) ) + { + v26 = *(short *)(v33 - 40); + dword_80AA1C = *(short *)(v33 - 40); + } + if ( dword_80AA18 > *(short *)v33 ) + dword_80AA18 = *(short *)v33; + if ( v27 < *(short *)v33 ) + { + v27 = *(short *)v33; + dword_80AA14 = *(short *)v33; + } + ++v35; + v33 += 2; + } + while ( v35 < v25->uNumVertices ); + v0 = a1; + } + dword_80AA20 = (dword_80AA20 + v4->sTextureDeltaU) << 16; + dword_80AA1C = ((v26 + v4->sTextureDeltaU) << 16) - 65536; + dword_80AA18 = (dword_80AA18 + v4->sTextureDeltaV) << 16; + dword_80AA14 = ((v27 + v4->sTextureDeltaV) << 16) - 65536; + } + while ( 1 ) + { + if ( !sr_sub_482E07(v3, v0) ) + sr_sub_48585C_mb_DrawSpan(v3, &v0[v3->field_8 + 640 * v3->field_A], 0); + v3->field_E = LOWORD(unnamed_6BE060[1]); + if ( v4->prolly_tail == v3 ) + break; + v3 = v3->pNext; + } + goto LABEL_14; + } + while ( 1 ) + { +LABEL_74: + if ( !sr_sub_4839BD(v3, v0) ) + sr_sub_48585C_mb_DrawSpan(v3, &v0[v3->field_8 + 640 * v3->field_A], 0); + v3->field_E = LOWORD(unnamed_6BE060[1]); + if ( v4->prolly_tail == v3 ) + break; + v3 = v3->pNext; + } + goto LABEL_14; + } + if ( v24 & 2 ) + goto LABEL_74; + while ( 1 ) + { + if ( !sr_sub_482A94(v3) ) + sr_sub_48585C_mb_DrawSpan(v3, &v0[v3->field_8 + 640 * v3->field_A], 0); + v3->field_E = LOWORD(unnamed_6BE060[1]); + if ( v4->prolly_tail == v3 ) + break; + v3 = v3->pNext; + } + } + } + else + { + v3->field_E = LOWORD(unnamed_6BE060[1]); + } + } + } + } +LABEL_14: + ++v34; + LOWORD(v2) = v34; + v36 += 67; + } + while ( v34 < (signed int)v37 ); + } + if ( pParty->uFlags & 2 ) + { + v6 = pOutdoorCamera->numStru148s; + v7 = 0; + uNumElementsIn80AA28 = 0; + if ( pOutdoorCamera->numStru148s > 0 ) + { + v8 = (char *)&array_77EC08[0].flags; + do + { + v2 = *(stru148 **)v8; + if ( (unsigned int)v2 & 0x20000 ) + { + ++v7; + *(int *)v8 = (unsigned int)v2 & 0xFFFDFFFF; + LOWORD(v2) = (short)v8 - 48; + *(&uNumElementsIn80AA28 + v7) = (unsigned int)(v8 - 48); + } + v8 += 268; + --v6; + } + while ( v6 ); + uNumElementsIn80AA28 = v7; + } + } + v9 = pOutdoorCamera->uNumSpans; + unnamed_6BE060[0] = pOutdoorCamera->uNumSpans; + if ( pOutdoorCamera->numStru148s >= 1999 + || (array_77EC08[1999]._48607B(&stru_8019C8), + array_77EC08[1999].ptr_38->_48694B(), + v2 = (stru148 *)&pBitmaps_LOD->pTextures[pOutdoor->uMainTile_BitmapID], + (array_77EC08[1999].pTexture = (Texture *)(pOutdoor->uMainTile_BitmapID != -1 ? (int)v2 : 0)) == 0) ) + return (signed __int16)v2; + array_77EC08[1999].field_58 = 23 - (-20 * pOutdoor->vSunlight.z >> 16); + if ( array_77EC08[1999].field_58 > 20 ) + array_77EC08[1999].field_58 = 20; + v10 = stru_5C6E00->SinCos(pIndoorCamera->sRotationX - stru_5C6E00->uIntegerHalfPi); + array_77EC08[1999].v_18.y = 0; + array_77EC08[1999].v_18.x = v10; + array_77EC08[1999].v_18.z = stru_5C6E00->SinCos(pIndoorCamera->sRotationX); + array_77EC08[1999].field_24 = 2048 - (pIndoorCamera->pos.z << 16); + a1a = (signed __int64)((double)(pIndoorCamera->pos.z * pOutdoorCamera->int_fov_rad) + / ((double)pOutdoorCamera->int_fov_rad + 8192.0) + + (double)pViewport->uScreenCenterY); + cos((double)pIndoorCamera->sRotationX * 0.0030664064); + sin((double)pIndoorCamera->sRotationX * 0.0030664064); + array_77EC08[1999]._48607B(&stru_8019C8); + array_77EC08[1999].ptr_38->_48694B(); + v2 = (stru148 *)&pBitmaps_LOD->pTextures[pOutdoor->uSky_TextureID]; + array_77EC08[1999].pTexture = (Texture *)(pOutdoor->uSky_TextureID != -1 ? (int)v2 : 0); + if ( !(pOutdoor->uSky_TextureID != -1 ? (int)v2 : 0) ) + return (signed __int16)v2; + array_77EC08[1999].field_58 = 0; + v11 = stru_5C6E00->SinCos(pIndoorCamera->sRotationX + 16 - stru_5C6E00->uIntegerHalfPi); + array_77EC08[1999].v_18.y = 0; + array_77EC08[1999].v_18.x = -v11; + array_77EC08[1999].v_18.z = -stru_5C6E00->SinCos(pIndoorCamera->sRotationX + 16); + LOWORD(v2) = 224 * LOWORD(pMiscTimer->uTotalGameTimeElapsed); + array_77EC08[1999].field_24 = 0x2000000u; + array_77EC08[1999].sTextureDeltaU = 224 * pMiscTimer->uTotalGameTimeElapsed; + array_77EC08[1999].sTextureDeltaV = 224 * pMiscTimer->uTotalGameTimeElapsed; + if ( day_attrib & 1 + && (LOWORD(v2) = LOWORD(pParty->uCurrentHour), pParty->uCurrentHour >= 5) + && pParty->uCurrentHour < 0x15 + || bUnderwater ) + { + v2 = (stru148 *)*(short *)PaletteManager::Get_Mist_or_Red_LUT(array_77EC08[1999].pTexture->palette_id2, 31, 1); + a1b = (unsigned int)v2; + if ( (signed int)v9 <= 0 ) + return (signed __int16)v2; + v29 = v9; + while ( 1 ) + { + v30 = &pSpans[v29 - 1]; + v2 = (stru148 *)v30->field_E; + if ( v2 != (stru148 *)unnamed_6BE060[1] ) + { + LOWORD(v2) = LOWORD(pViewport->uViewportX); + if ( v30->field_8 >= (signed int)pViewport->uViewportX ) + goto LABEL_124; + if ( v30->field_C == pViewport->uViewportX ) + { + v30->field_E = LOWORD(unnamed_6BE060[1]); + } + else + { + v30->field_8 = LOWORD(pViewport->uViewportX); + v30->field_C -= LOWORD(pViewport->uViewportX); + if ( v30->field_C >= 0 ) + { +LABEL_124: + v31 = v30->field_C; + v30->pParent = &array_77EC08[1999]; + fill_pixels_fast( + a1b, + &pRenderer->pTargetSurface[v30->field_8 + pRenderer->uTargetSurfacePitch * v30->field_A], + v31); + j_memset32(-65536, &pRenderer->pActiveZBuffer[v30->field_8 + 640 * v30->field_A], v30->field_C); + goto LABEL_125; + } + LOWORD(v2) = LOWORD(unnamed_6BE060[1]); + v30->field_E = LOWORD(unnamed_6BE060[1]); + } + } +LABEL_125: + --v29; + --v9; + if ( !v9 ) + return (signed __int16)v2; + } + } + if ( (signed int)v9 > 0 ) + { + v12 = v9; + do + { + v13 = &pSpans[v12 - 1]; + v2 = (stru148 *)v13->field_E; + if ( v2 != (stru148 *)unnamed_6BE060[1] ) + { + LOWORD(v2) = LOWORD(pViewport->uViewportX); + if ( v13->field_8 >= (signed int)pViewport->uViewportX ) + goto LABEL_109; + if ( v13->field_C != pViewport->uViewportX ) + { + v13->field_8 = LOWORD(pViewport->uViewportX); + v13->field_C -= LOWORD(pViewport->uViewportX); + if ( v13->field_C >= 0 ) + { +LABEL_109: + if ( pOutdoorCamera->bNoSky ) + { + const_1_0(); + } + else + { + v13->pParent = &array_77EC08[1999]; + if ( !Render::DrawSkySW(v13, &array_77EC08[1999], a1a) ) + j_memset32(-65536, &pRenderer->pActiveZBuffer[v13->field_8 + 640 * v13->field_A], v13->field_C); + } + } + LOWORD(v2) = LOWORD(unnamed_6BE060[1]); + v13->field_E = LOWORD(unnamed_6BE060[1]); + goto LABEL_114; + } + v13->field_E = LOWORD(unnamed_6BE060[1]); + } +LABEL_114: + --v12; + --v9; + } + while ( v9 ); + } + return (signed __int16)v2; +} +// 6BE030: using guessed type int day_attrib; +// 6BE3C4: using guessed type char bUnderwater; +// 80AA10: using guessed type char byte_80AA10; +// 80AA14: using guessed type int dword_80AA14; +// 80AA18: using guessed type int dword_80AA18; +// 80AA1C: using guessed type int dword_80AA1C; +// 80AA20: using guessed type int dword_80AA20; + +//----- (00485044) -------------------------------------------------------- +int Render::DrawSkySW(Span *a1, stru148 *a2, int a3) +{ + stru148 *v3; // esi@1 + Span *v4; // edi@1 + float v5; // ST2C_4@1 + signed int result; // eax@2 + int v7; // ST40_4@3 + stru149 *v8; // eax@3 + int v9; // ebx@3 + int v10; // ecx@3 + int v11; // edx@3 + int v12; // eax@3 + int v13; // ST28_4@5 + int v14; // eax@5 + signed __int64 v15; // qtt@11 + int v16; // ST28_4@11 + int v17; // eax@11 + signed int v18; // ecx@11 + int v19; // ST40_4@11 + int v20; // ST3C_4@11 + int v21; // ST30_4@11 + void *v22; // eax@11 + Texture *v23; // esi@11 + int v24; // ecx@11 + unsigned int v25; // esi@11 + int v26; // edi@11 + unsigned __int16 *v27; // eax@11 + int *v28; // ebx@12 + int v29; // edx@13 + unsigned __int16 v30; // cx@13 + int v31; // edx@14 + unsigned __int16 v32; // cx@14 + unsigned __int8 v33; // sf@15 + unsigned __int8 v34; // of@15 + double v35; // [sp+14h] [bp-38h]@1 + int v36; // [sp+18h] [bp-34h]@3 + signed int v37; // [sp+18h] [bp-34h]@11 + int v38; // [sp+1Ch] [bp-30h]@3 + signed int v39; // [sp+1Ch] [bp-30h]@11 + int v40; // [sp+20h] [bp-2Ch]@3 + void *v41; // [sp+20h] [bp-2Ch]@11 + int v42; // [sp+24h] [bp-28h]@3 + unsigned __int8 *v43; // [sp+24h] [bp-28h]@11 + int v44; // [sp+28h] [bp-24h]@11 + int v45; // [sp+2Ch] [bp-20h]@3 + signed int v46; // [sp+30h] [bp-1Ch]@3 + __int16 v47; // [sp+30h] [bp-1Ch]@11 + signed int v48; // [sp+34h] [bp-18h]@3 + int v49; // [sp+34h] [bp-18h]@11 + int v50; // [sp+38h] [bp-14h]@3 + unsigned __int16 *v51; // [sp+38h] [bp-14h]@11 + int v52; // [sp+3Ch] [bp-10h]@4 + int a1a; // [sp+40h] [bp-Ch]@3 + int v54; // [sp+44h] [bp-8h]@3 + int v55; // [sp+48h] [bp-4h]@3 + int v56; // [sp+54h] [bp+8h]@11 + int *v57; // [sp+54h] [bp+8h]@11 + + v3 = a2; + v4 = a1; + v5 = (double)(pViewport->uViewportZ - pViewport->uViewportX) * 0.5 / tan(0.6457717418670654) + 0.5; + v35 = v5 + 6.7553994e15; + if ( LODWORD(v35) ) + { + v55 = 65536 / SLODWORD(v35); + v7 = 65536 / SLODWORD(v35) * (a3 - v4->field_A); + v8 = v3->ptr_38; + v42 = ((unsigned __int64)(v3->ptr_38->field_14 * (signed __int64)v7) >> 16) + v8->field_C; + v40 = ((unsigned __int64)(v8->field_20 * (signed __int64)v7) >> 16) + v3->ptr_38->field_18; + v38 = pOutdoorCamera->camera_rotation_y_int_sine; + HIDWORD(v35) = pOutdoorCamera->camera_rotation_y_int_cosine; + v45 = v4->field_C; + v9 = ((unsigned __int64)(v3->v_18.z * (signed __int64)v7) >> 16) + v3->v_18.x; + v10 = 65536 / SLODWORD(v35) * (pViewport->uScreenCenterX - v4->field_8); + v48 = 0; + v50 = 65536 / SLODWORD(v35) * (pViewport->uScreenCenterX - v4->field_8); + v46 = -v3->field_24; + v11 = v4->field_A - 1; + v54 = v11; + v12 = 65536 / SLODWORD(v35) * (a3 - v11); + a1a = 65536 / SLODWORD(v35) * (a3 - v11); + while ( 1 ) + { + v52 = v9; + if ( v9 ) + { + v13 = abs(v46 >> 14); + v14 = abs(v9); + v11 = v54; + v10 = v50; + if ( v13 <= v14 ) + break; + v12 = a1a; + } + if ( v11 <= (signed int)pViewport->uViewportY ) + break; + v9 = ((unsigned __int64)(v3->v_18.z * (signed __int64)v12) >> 16) + v3->v_18.x; + --v54; + a1a += v55; + v12 = a1a; + v11 = v54; + v48 = 1; + } + if ( v48 ) + v52 = ((unsigned __int64)(v3->v_18.z * (signed __int64)(v55 * (a3 + (signed int)v4->field_A - 2 * v11))) >> 16) + + v3->v_18.x; + LODWORD(v15) = v46 << 16; + HIDWORD(v15) = v46 >> 16; + v16 = v42 + ((unsigned __int64)(v3->ptr_38->field_10 * (signed __int64)v10) >> 16); + v17 = v40 + ((unsigned __int64)(v3->ptr_38->field_1C * (signed __int64)v10) >> 16); + v18 = v15 / v52; + v43 = v3->pTexture->pLevelOfDetail0; + v19 = v3->sTextureDeltaU + ((signed int)((unsigned __int64)(v16 * v15 / v52) >> 16) >> 3); + v56 = v15 / v52; + v20 = v3->sTextureDeltaV + ((signed int)((unsigned __int64)(v17 * v15 / v52) >> 16) >> 3); + v21 = (unsigned __int64)(v55 * (signed __int64)v56) >> 16; + v39 = (signed int)((unsigned __int64)(v21 * (signed __int64)v38) >> 16) >> 3; + v37 = (signed int)((unsigned __int64)(v21 * (signed __int64)v36) >> 16) >> 3; + v22 = sr_sub_47C178(v18, v3, 0, 1); + v23 = v3->pTexture; + v41 = v22; + v47 = 16 - v23->uWidthLn2; + v44 = v23->uTextureWidth - 1; + v49 = (v23->uTextureHeight << 16) - 65536; + v24 = v4->field_8; + v51 = &pRenderer->pTargetSurface[v24 + pRenderer->uTargetSurfacePitch * v4->field_A]; + v57 = &pRenderer->pActiveZBuffer[v24 + 640 * v4->field_A]; + v25 = v19; + v26 = v20; + v27 = v51; + if ( !(v45 & 1) ) + goto LABEL_15; + --v45; + v27 = v51 - 1; + v28 = v57; + ++v57; + while ( 1 ) + { + *v28 = -65536; + v31 = v44 & (v25 >> 16); + v27 += 2; + v25 += v39; + v32 = *((short *)v41 + *(&v43[v31] + ((v49 & (unsigned int)v26) >> v47))); + v26 += v37; + *(v27 - 1) = v32; +LABEL_15: + v34 = __OFSUB__(v45, 2); + v33 = v45 - 2 < 0; + v45 -= 2; + if ( v33 ^ v34 ) + break; + v29 = v44 & (v25 >> 16); + v25 += v39; + v30 = *((short *)v41 + *(&v43[v29] + ((v49 & (unsigned int)v26) >> v47))); + v26 += v37; + v28 = v57; + *v27 = v30; + v57 += 2; + v28[1] = -65536; + } + result = 1; + } + else + { + result = 0; + } + return result; +} + +//----- (0047F5C6) -------------------------------------------------------- +float Render::DrawBezierTerrain() +{ + //__debugbreak();Ritor1: it's temporarily + //return 0; + + unsigned int v0; // ebx@1 + unsigned int v1; // edi@1 + unsigned int v2; // eax@1 + int v3; // eax@3 + int v4; // edi@3 + int v5; // ebx@3 + int v6; // esi@3 + unsigned int v7; // eax@3 + int v8; // eax@4 + unsigned int v9; // eax@6 + int v10; // eax@7 + int v11; // ebx@9 + int v12; // edi@9 + int v13; // eax@21 + int v14; // eax@31 + int v15; // edi@33 + float v16; // eax@34 + int v17; // edx@34 + int v18; // ebx@34 + int v19; // eax@36 + int v20; // eax@39 + int v21; // ecx@43 + char v22; // zf@44 + int v23; // ecx@47 + int v24; // edi@52 + float v25; // eax@54 + int v26; // ecx@54 + int v27; // eax@56 + int v28; // edx@60 + int v29; // ecx@61 + int v30; // ecx@64 + int v31; // ecx@68 + int v32; // eax@70 + int v33; // ecx@71 + int v34; // eax@73 + int v35; // ecx@77 + int v36; // ecx@81 + int v37; // ecx@86 + float v38; // eax@88 + IndoorCameraD3D *v39; // ecx@88 + int v40; // eax@90 + int v41; // edx@94 + int v42; // ecx@95 + int v43; // ecx@98 + int v44; // ecx@102 + int v45; // eax@104 + int v46; // eax@107 + int v47; // ecx@111 + int v48; // ecx@115 + int v49; // edi@120 + float v50; // eax@122 + int v51; // ecx@122 + int v52; // eax@124 + int v53; // edx@128 + int v54; // ecx@129 + int v55; // ecx@132 + int v56; // eax@139 + int v57; // ecx@140 + int v58; // eax@142 + int v59; // ecx@146 + int v60; // ecx@147 + int v61; // ecx@150 + int v62; // ecx@155 + float v63; // eax@157 + IndoorCameraD3D *v64; // ecx@157 + int v65; // eax@159 + int v66; // edx@163 + int v67; // ecx@164 + int v68; // ecx@167 + int v69; // eax@173 + int v70; // edi@178 + int v71; // eax@178 + int v72; // ecx@178 + int v73; // ebx@180 + int v74; // eax@182 + int v75; // eax@184 + IndoorCameraD3D *v76; // ecx@184 + int v77; // ecx@184 + int v79; // ebx@185 + int v127; // esi@185 + int v86; // edi@196 + int v87; // eax@196 + int v88; // ecx@196 + int v89; // eax@198 + int v90; // ecx@200 + int v92; // ebx@203 + int v93; // ST08_4@204 + int v97; // ST08_4@204 + float result; // eax@212 + char v102; // [sp+Ch] [bp-68h]@191 + __int16 v103; // [sp+10h] [bp-64h]@190 + __int16 v104; // [sp+12h] [bp-62h]@190 + int v105; // [sp+1Ch] [bp-58h]@1 + int v106; // [sp+20h] [bp-54h]@3 + int v107; // [sp+24h] [bp-50h]@3 + int v108; // [sp+28h] [bp-4Ch]@9 + int v109; // [sp+2Ch] [bp-48h]@9 + int v110; // [sp+30h] [bp-44h]@9 + int v111; // [sp+34h] [bp-40h]@3 + int v112; // [sp+38h] [bp-3Ch]@6 + IndoorCameraD3D *a1; // [sp+3Ch] [bp-38h]@9 + int v114; // [sp+40h] [bp-34h]@9 + int v115; // [sp+44h] [bp-30h]@9 + int v116; // [sp+48h] [bp-2Ch]@9 + int v117; // [sp+4Ch] [bp-28h]@9 + int v118; // [sp+50h] [bp-24h]@9 + int v119; // [sp+54h] [bp-20h]@1 + int v120; // [sp+58h] [bp-1Ch]@1 + int i; // [sp+5Ch] [bp-18h]@1 + int v122; // [sp+60h] [bp-14h]@1 + int v123; // [sp+64h] [bp-10h]@1 + float v124; // [sp+68h] [bp-Ch]@1 + int v125; // [sp+6Ch] [bp-8h]@9 + float v126; // [sp+70h] [bp-4h]@9 + + memset(&v102, 0, sizeof(v102)); + v105 = pIndoorCamera->sRotationY / ((signed int)stru_5C6E00->uIntegerHalfPi / 2); + v0 = stru_5C6E00->uDoublePiMask & (stru_5C6E00->uIntegerDoublePi - pIndoorCamera->sRotationY); + v1 = stru_5C6E00->uDoublePiMask & (stru_5C6E00->uIntegerPi + v0); + LODWORD(v124) = (signed int)((pIndoorCamera->uMapGridCellX << 16) + + 3 + * stru_5C6E00->SinCos( + stru_5C6E00->uDoublePiMask & (stru_5C6E00->uIntegerPi + v0))) >> 16; + v123 = (signed int)((pIndoorCamera->uMapGridCellZ << 16) + + 3 * stru_5C6E00->SinCos(v1 - stru_5C6E00->uIntegerHalfPi)) >> 16; + v120 = pOutdoorCamera->outdoor_grid_band_3 + LODWORD(v124); + v119 = pOutdoorCamera->outdoor_grid_band_3 + v123; + v2 = pOutdoorCamera->uCameraFovInDegrees + 15; + i = LODWORD(v124) - pOutdoorCamera->outdoor_grid_band_3; + v122 = v123 - pOutdoorCamera->outdoor_grid_band_3; + if ( (signed int)(pOutdoorCamera->uCameraFovInDegrees + 15) > 90 ) + v2 = 90; + v3 = (signed int)(v2 << 11) / 720; + v4 = stru_5C6E00->uDoublePiMask & (v0 - v3); + v5 = stru_5C6E00->uDoublePiMask & (v3 + v0); + v106 = stru_5C6E00->SinCos(v4); + v107 = stru_5C6E00->SinCos(v4 - stru_5C6E00->uIntegerHalfPi); + v111 = stru_5C6E00->SinCos(v5); + v6 = stru_5C6E00->SinCos(v5 - stru_5C6E00->uIntegerHalfPi); + v7 = v4 & stru_5C6E00->uPiMask; + if ( (signed int)(v4 & stru_5C6E00->uPiMask) >= (signed int)stru_5C6E00->uIntegerHalfPi ) + v8 = -stru_5C6E00->pTanTable[stru_5C6E00->uIntegerPi - v7]; + else + v8 = stru_5C6E00->pTanTable[v7]; + v112 = abs(v8); + v9 = v5 & stru_5C6E00->uPiMask; + if ( (signed int)(v5 & stru_5C6E00->uPiMask) >= (signed int)stru_5C6E00->uIntegerHalfPi ) + v10 = -stru_5C6E00->pTanTable[stru_5C6E00->uIntegerPi - v9]; + else + v10 = stru_5C6E00->pTanTable[v9]; + v108 = abs(v10); + v11 = LODWORD(v124); + v12 = v123; + v114 = 0; + v115 = 0; + a1 = 0; + v125 = 0; + v110 = 2 * (v106 >= 0) - 1; + v126 = v124; + v118 = v123; + v109 = 2 * (v107 >= 0) - 1; + v107 = 2 * (v111 >= 0) - 1; + terrain_76E1C8[0] = 65535; + v116 = 1; + v106 = 2 * (v6 >= 0) - 1; + v117 = 1; + terrain_76E3C8[0] = 65535; + terrain_76DDC8[0] = 65535; + terrain_76DFC8[0] = 65535; + while ( 1 ) + { + if ( v112 >= 65536 ) + { + v111 = 4294967296i64 / v112; + v114 += v111; + if ( v114 >= 65536 ) + { + v11 += v110; + v114 = (unsigned __int16)v114; + } + v12 += v109; + } + else + { + v11 += v110; + v115 += v112; + if ( v115 >= 65536 ) + { + v12 += v109; + v115 = (unsigned __int16)v115; + } + } + if ( v116 > 128 || v11 < i || v11 > v120 || v12 < v122 || v12 > v119 ) + break; + v13 = v116++; + terrain_76E3C8[v13] = v11; + terrain_76E1C8[v13] = v12; + } + while ( 1 ) + { + if ( v108 >= 65536 ) + { + v111 = 4294967296i64 / v108; + a1 = (IndoorCameraD3D *)((char *)a1 + v111); + if ( (signed int)a1 >= 65536 ) + { + LODWORD(v126) += v107; + a1 = (IndoorCameraD3D *)(unsigned __int16)a1; + } + v118 += v106; + } + else + { + v125 += v108; + LODWORD(v126) += v107; + if ( v125 >= 65536 ) + { + v118 += v106; + v125 = (unsigned __int16)v125; + } + } + if ( v117 >= 128 ) + break; + if ( SLODWORD(v126) < i ) + break; + if ( SLODWORD(v126) > v120 ) + break; + v14 = v118; + if ( v118 < v122 ) + break; + if ( v118 > v119 ) + break; + v15 = v117++; + terrain_76DFC8[v15] = LODWORD(v126); + terrain_76DDC8[v15] = v14; + } + LODWORD(v16) = 0; + LODWORD(v126) = 0; + v17 = v117 - 1; + v18 = v116 - 1; + switch ( v105 ) + { + case 0: + case 7: + v116 = terrain_76DFC8[v17]; + if ( v120 > v116 ) + { + v125 = v120; + memset32(terrain_76D9C8, v119 + 1, v120 - v116 + 1); + v19 = v120; + do + terrain_76DBC8[LODWORD(v126)++] = v19--; + while ( v19 >= v116 ); + if ( terrain_76DFC8[v17] == terrain_76DDC8[v17 + 127] ) + { + do + v20 = terrain_76DDC8[v17-- + 127]; + while ( v20 == terrain_76DDC8[v17 + 127] ); + } + v16 = v126; + --v17; + } + if ( v17 < 0 ) + v17 = 0; + v21 = terrain_76DFC8[v17]; + while ( 1 ) + { + v125 = v21; + if ( v21 < SLODWORD(v124) ) + break; + terrain_76DBC8[LODWORD(v16)] = v21; + v22 = terrain_76DDC8[v17] == 65535; + terrain_76D9C8[LODWORD(v16)] = terrain_76DDC8[v17] + 1; + if ( v22 ) + { + terrain_76D9C8[LODWORD(v16)] = v123 + 1; + break; + } + if ( !v17 ) + break; + if ( terrain_76DFC8[v17] == terrain_76DDC8[v17 + 127] ) + { + do + v23 = terrain_76DDC8[v17-- + 127]; + while ( v23 == terrain_76DDC8[v17 + 127] ); + } + --v17; + v21 = v125 - 1; + ++LODWORD(v16); + } + LODWORD(v16) = 0; + v24 = terrain_76E3C8[v18]; + LODWORD(v126) = 0; + if ( v120 > v24 ) + { + v125 = v120; + memset32(terrain_76D5C8, v122, v120 - v24 + 1); + do + { + v25 = v126; + v26 = v125--; + ++LODWORD(v126); + terrain_76D7C8[LODWORD(v25)] = v26; + } + while ( v125 >= terrain_76E3C8[v18] ); + if ( terrain_76E3C8[v18] == terrain_76E1C8[v18 + 127] ) + { + do + v27 = terrain_76E1C8[v18-- + 127]; + while ( v27 == terrain_76E1C8[v18 + 127] ); + } + v16 = v126; + --v18; + } + if ( v18 < 0 ) + v18 = 0; + v28 = terrain_76E3C8[v18]; + while ( v28 >= SLODWORD(v124) ) + { + v29 = terrain_76E1C8[v18]; + terrain_76D7C8[LODWORD(v16)] = v28; + terrain_76D5C8[LODWORD(v16)] = v29; + if ( v29 == 65535 ) + { + v31 = v123; + goto LABEL_172; + } + if ( !v18 ) + break; + if ( terrain_76E3C8[v18] == terrain_76E1C8[v18 + 127] ) + { + do + v30 = terrain_76E1C8[v18-- + 127]; + while ( v30 == terrain_76E1C8[v18 + 127] ); + } + --v18; + --v28; + ++LODWORD(v16); + } + break; + case 1: + case 2: + v116 = terrain_76DDC8[v17]; + if ( v122 < v116 ) + { + v106 = v122; + memset32(terrain_76DBC8, v120 + 1, v116 - v122 + 1); + v32 = v122; + do + { + v33 = LODWORD(v126)++; + terrain_76D9C8[v33] = v32++; + } + while ( v32 <= v116 ); + if ( terrain_76DDC8[v17] == terrain_76DBC8[v17 + 127] ) + { + do + v34 = terrain_76DBC8[v17-- + 127]; + while ( v34 == terrain_76DBC8[v17 + 127] ); + } + v16 = v126; + --v17; + } + if ( v17 < 0 ) + v17 = 0; + v35 = terrain_76DDC8[v17]; + v125 = terrain_76DDC8[v17]; + while ( v35 <= v123 ) + { + v22 = terrain_76DFC8[v17] == 65535; + terrain_76DBC8[LODWORD(v16)] = terrain_76DFC8[v17] + 1; + terrain_76D9C8[LODWORD(v16)] = v125; + if ( v22 ) + { + terrain_76DBC8[LODWORD(v16)] = LODWORD(v124) + 1; + break; + } + if ( !v17 ) + break; + if ( terrain_76DDC8[v17] == terrain_76DBC8[v17 + 127] ) + { + do + v36 = terrain_76DBC8[v17-- + 127]; + while ( v36 == terrain_76DBC8[v17 + 127] ); + } + --v17; + ++v125; + v35 = v125; + ++LODWORD(v16); + } + LODWORD(v16) = 0; + LODWORD(v126) = 0; + v37 = terrain_76E1C8[v18]; + if ( v122 < v37 ) + { + a1 = (IndoorCameraD3D *)v122; + memset32(terrain_76D7C8, i, v37 - v122 + 1); + do + { + v38 = v126; + v39 = a1; + ++LODWORD(v126); + a1 = (IndoorCameraD3D *)((char *)a1 + 1); + terrain_76D5C8[LODWORD(v38)] = (int)v39; + } + while ( (signed int)a1 <= terrain_76E1C8[v18] ); + if ( terrain_76E1C8[v18] == terrain_76DFC8[v18 + 127] ) + { + do + v40 = terrain_76DFC8[v18-- + 127]; + while ( v40 == terrain_76DFC8[v18 + 127] ); + } + v16 = v126; + --v18; + } + if ( v18 < 0 ) + v18 = 0; + v41 = terrain_76E1C8[v18]; + while ( v41 <= v123 ) + { + v42 = terrain_76E3C8[v18]; + terrain_76D5C8[LODWORD(v16)] = v41; + terrain_76D7C8[LODWORD(v16)] = v42; + if ( v42 == 65535 ) + { + v44 = LODWORD(v124); + goto LABEL_137; + } + if ( !v18 ) + break; + if ( terrain_76E1C8[v18] == terrain_76DFC8[v18 + 127] ) + { + do + v43 = terrain_76DFC8[v18-- + 127]; + while ( v43 == terrain_76DFC8[v18 + 127] ); + } + --v18; + ++v41; + ++LODWORD(v16); + } + break; + case 5: + case 6: + v116 = terrain_76DDC8[v17]; + if ( v119 > v116 ) + { + v106 = v119; + memset32(terrain_76DBC8, i, v119 - v116 + 1); + v45 = v119; + do + terrain_76D9C8[LODWORD(v126)++] = v45--; + while ( v45 >= v116 ); + if ( terrain_76DDC8[v17] == terrain_76DBC8[v17 + 127] ) + { + do + v46 = terrain_76DBC8[v17-- + 127]; + while ( v46 == terrain_76DBC8[v17 + 127] ); + } + v16 = v126; + --v17; + } + if ( v17 < 0 ) + v17 = 0; + v47 = terrain_76DDC8[v17]; + v125 = terrain_76DDC8[v17]; + while ( v47 >= v123 ) + { + v22 = terrain_76DFC8[v17] == 65535; + terrain_76DBC8[LODWORD(v16)] = terrain_76DFC8[v17]; + terrain_76D9C8[LODWORD(v16)] = v125; + if ( v22 ) + { + terrain_76DBC8[LODWORD(v16)] = LODWORD(v124); + break; + } + if ( !v17 ) + break; + if ( terrain_76DDC8[v17] == terrain_76DBC8[v17 + 127] ) + { + do + v48 = terrain_76DBC8[v17-- + 127]; + while ( v48 == terrain_76DBC8[v17 + 127] ); + } + --v17; + --v125; + v47 = v125; + ++LODWORD(v16); + } + LODWORD(v16) = 0; + v49 = terrain_76E1C8[v18]; + LODWORD(v126) = 0; + if ( v119 > v49 ) + { + v125 = v119; + memset32(terrain_76D7C8, v120 + 1, v119 - v49 + 1); + do + { + v50 = v126; + v51 = v125--; + ++LODWORD(v126); + terrain_76D5C8[LODWORD(v50)] = v51; + } + while ( v125 >= terrain_76E1C8[v18] ); + if ( terrain_76E1C8[v18] == terrain_76DFC8[v18 + 127] ) + { + do + v52 = terrain_76DFC8[v18-- + 127]; + while ( v52 == terrain_76DFC8[v18 + 127] ); + } + v16 = v126; + --v18; + } + if ( v18 < 0 ) + v18 = 0; + v53 = terrain_76E1C8[v18]; + while ( v53 >= v123 ) + { + v54 = terrain_76E3C8[v18]; + terrain_76D5C8[LODWORD(v16)] = v53; + terrain_76D7C8[LODWORD(v16)] = v54 + 1; + if ( v54 == 65535 ) + { + v44 = LODWORD(v124) + 1; +LABEL_137: + terrain_76D7C8[LODWORD(v16)] = v44; + goto LABEL_173; + } + if ( !v18 ) + goto LABEL_173; + if ( terrain_76E1C8[v18] == terrain_76DFC8[v18 + 127] ) + { + do + v55 = terrain_76DFC8[v18-- + 127]; + while ( v55 == terrain_76DFC8[v18 + 127] ); + } + --v18; + --v53; + ++LODWORD(v16); + } + break; + case 3: + case 4: + v116 = terrain_76DFC8[v17]; + if ( i < v116 ) + { + v106 = i; + memset32(terrain_76D9C8, v122, v116 - i + 1); + v56 = i; + do + { + v57 = LODWORD(v126)++; + terrain_76DBC8[v57] = v56++; + } + while ( v56 <= v116 ); + if ( terrain_76DFC8[v17] == terrain_76DDC8[v17 + 127] ) + { + do + v58 = terrain_76DDC8[v17-- + 127]; + while ( v58 == terrain_76DDC8[v17 + 127] ); + } + v16 = v126; + --v17; + } + if ( v17 < 0 ) + v17 = 0; + v59 = terrain_76DFC8[v17]; + while ( 1 ) + { + v125 = v59; + if ( v59 > SLODWORD(v124) ) + break; + terrain_76DBC8[LODWORD(v16)] = v59; + v60 = terrain_76DDC8[v17]; + terrain_76D9C8[LODWORD(v16)] = v60; + if ( v60 == 65535 ) + { + terrain_76D9C8[LODWORD(v16)] = v123; + break; + } + if ( !v17 ) + break; + if ( terrain_76DFC8[v17] == terrain_76DDC8[v17 + 127] ) + { + do + v61 = terrain_76DDC8[v17-- + 127]; + while ( v61 == terrain_76DDC8[v17 + 127] ); + } + --v17; + v59 = v125 + 1; + ++LODWORD(v16); + } + LODWORD(v16) = 0; + LODWORD(v126) = 0; + v62 = terrain_76E3C8[v18]; + if ( i < v62 ) + { + a1 = (IndoorCameraD3D *)i; + memset32(terrain_76D5C8, v119 + 1, v62 - i + 1); + do + { + v63 = v126; + v64 = a1; + ++LODWORD(v126); + a1 = (IndoorCameraD3D *)((char *)a1 + 1); + terrain_76D7C8[LODWORD(v63)] = (int)v64; + } + while ( (signed int)a1 <= terrain_76E3C8[v18] ); + if ( terrain_76E3C8[v18] == terrain_76E1C8[v18 + 127] ) + { + do + v65 = terrain_76E1C8[v18-- + 127]; + while ( v65 == terrain_76E1C8[v18 + 127] ); + } + v16 = v126; + --v18; + } + if ( v18 < 0 ) + v18 = 0; + v66 = terrain_76E3C8[v18]; + while ( v66 <= SLODWORD(v124) ) + { + v67 = terrain_76E1C8[v18]; + terrain_76D7C8[LODWORD(v16)] = v66; + terrain_76D5C8[LODWORD(v16)] = v67 + 1; + if ( v67 == 65535 ) + { + v31 = v123 + 1; +LABEL_172: + terrain_76D5C8[LODWORD(v16)] = v31; + goto LABEL_173; + } + if ( !v18 ) + goto LABEL_173; + if ( terrain_76E3C8[v18] == terrain_76E1C8[v18 + 127] ) + { + do + v68 = terrain_76E1C8[v18-- + 127]; + while ( v68 == terrain_76E1C8[v18 + 127] ); + } + --v18; + ++v66; + ++LODWORD(v16); + } + break; + default: + break; + } +LABEL_173: + v69 = LODWORD(v16) - 1; + ptr_801A08 = pVerticesSR_806210; + ptr_801A04 = pVerticesSR_801A10; + LODWORD(v126) = v69; + if ( v105 && v105 != 7 && v105 != 3 && v105 != 4 ) + { + for ( i = v69; i >= 1; --i ) + { + v70 = i; + v71 = terrain_76D7C8[i]; + v72 = terrain_76DBC8[i]; + if ( v71 < v72 ) + { + terrain_76DBC8[v70] = v71; + terrain_76D7C8[v70] = v72; + } + v73 = terrain_76DBC8[v70]; + v111 = 0; + if ( v73 <= 0 ) + v73 = -v73; + v74 = terrain_76D7C8[v70]; + if ( v74 <= 0 ) + v74 = -v74; + v75 = v74 + 2; + v76 = pGame->pIndoorCameraD3D; + v107 = v75; + a1 = v76; + v77 = v73 - 2; + if ( v73 - 2 < v75 ) + { + v127 = 0; + v79 = (v73 - 66) << 9; + v116 = v77; + v105 = v79; + v111 = v75 - v77; + do + { + *(float *)&v106 = (double)v105; + *(float *)((char *)&ptr_801A08->vWorldPosition.x + v127) = *(float *)&v106; + v105 = (64 - *(int *)((char *)terrain_76D9C8 + v70)) << 9; + *(float *)((char *)&ptr_801A08->vWorldPosition.y + v127) = (double)v105; + v105 = pOutdoor->GetHeightOnTerrain(v112, *(int *)((char *)terrain_76D9C8 + v70)); + *(float *)((char *)&ptr_801A08->vWorldPosition.z + v127) = (double)v105; + *(float *)((char *)&ptr_801A04->vWorldPosition.x + v127) = *(float *)&v106; + v105 = (63 - *(int *)((char *)terrain_76D9C8 + v70)) << 9; + *(float *)((char *)&ptr_801A04->vWorldPosition.y + v127) = (double)v105; + v105 = pOutdoor->GetHeightOnTerrain(v112, *(int *)((char *)terrain_76D9C8 + v70) + 1); + *(float *)((char *)&ptr_801A04->vWorldPosition.z + v127) = (double)v105; + if ( !byte_4D864C || !(pGame->uFlags & 0x80) ) + { + a1->ViewTransform((RenderVertexSoft *)(char *)ptr_801A08 + v127, 1); + a1->ViewTransform((RenderVertexSoft *)(char *)ptr_801A04 + v127, 1); + a1->Project((RenderVertexSoft *)(char *)ptr_801A08 + v127, 1, 0); + a1->Project((RenderVertexSoft *)(char *)ptr_801A04 + v127, 1, 0); + } + v79 += 512; + v127 += 48; + ++v116; + v105 = v79; + } + while ( v116 < v107 ); + } + v103 = abs((int)pIndoorCamera->uMapGridCellZ - terrain_76D9C8[v70]); + v104 = abs((int)pIndoorCamera->uMapGridCellX - terrain_76DBC8[v70]); + if ( pRenderer->pRenderD3D ) + Render::DrawTerrainD3D(v111, 0, (int)&v102); + else + Render::DrawTerrainSW(v111, 0, (int)&v102); + } + } + else + { + for ( i = v69; i >= 1; --i ) + { + v86 = i; + v87 = terrain_76D5C8[i]; + v88 = terrain_76D9C8[i]; + if ( v87 < v88 ) + { + terrain_76D9C8[v86] = v87; + terrain_76D5C8[v86] = v88; + } + v89 = terrain_76D9C8[v86]; + v111 = 0; + if ( v89 <= 0 ) + v89 = -v89; + v90 = terrain_76D5C8[v86]; + if ( v90 <= 0 ) + v90 = -v90; + a1 = pGame->pIndoorCameraD3D; + v107 = v90 + 2; + if ( v89 - 2 < v90 + 2 ) + { + v86 = 0; + v116 = v89 - 2; + v92 = (66 - v89) << 9; + v105 = (66 - v89) << 9; + v111 = v90 + 2 - (v89 - 2); + do + { + v93 = v116; + v106 = (*(int *)((char *)terrain_76DBC8 + v86) - 64) << 9; + *(float *)((char *)&ptr_801A08->vWorldPosition.x + v86) = (double)v106; + *(float *)&v105 = (double)v105; + *(float *)((char *)&ptr_801A08->vWorldPosition.y + v86) = *(float *)&v105; + v106 = pOutdoor->GetHeightOnTerrain(*(int *)((char *)terrain_76DBC8 + v86), v93); + v97 = v116; + *(float *)((char *)&ptr_801A08->vWorldPosition.z + v86) = (double)v106; + v106 = (*(int *)((char *)terrain_76DBC8 + v86) - 63) << 9; + *(float *)((char *)&ptr_801A04->vWorldPosition.x + v86) = (double)v106; + *(float *)((char *)&ptr_801A04->vWorldPosition.y + v86) = *(float *)&v105; + v105 = pOutdoor->GetHeightOnTerrain(*(int *)((char *)terrain_76DBC8 + v86) + 1, v97); + *(float *)((char *)&ptr_801A04->vWorldPosition.z + v86) = (double)v105; + if ( !byte_4D864C || !(pGame->uFlags & 0x80) ) + { + a1->ViewTransform((RenderVertexSoft *)(char *)ptr_801A08 + v86, 1); + a1->ViewTransform((RenderVertexSoft *)(char *)ptr_801A04 + v86, 1); + a1->Project((RenderVertexSoft *)(char *)ptr_801A08 + v86, 1, 0); + a1->Project((RenderVertexSoft *)(char *)ptr_801A04 + v86, 1, 0); + } + v92 -= 512; + v86 += 48; + ++v116; + v105 = v92; + } + while ( v116 < v107 ); + } + v103 = abs((int)pIndoorCamera->uMapGridCellX - terrain_76DBC8[v86]); + v104 = abs((int)pIndoorCamera->uMapGridCellZ - terrain_76D9C8[v86]); + if ( pRenderer->pRenderD3D ) + Render::DrawTerrainD3D(v111, 1, (int)&v102); + else + Render::DrawTerrainSW(v111, 1, (int)&v102); + } + } + result = v126; + pOutdoorCamera->field_40 = v126; + return result; +} +// 47FFC4: inconsistent fpu stack +// 4D864C: using guessed type char byte_4D864C; + + + +//----- (0048034E) -------------------------------------------------------- +void Render::DrawTerrainD3D(int a1, int edx0, int a3) +{ + int v3; // esi@1 + int v4; // edi@1 + int v5; // ebx@2 + int v6; // eax@2 + int v7; // eax@3 + RenderVertexSoft *v8; // edi@3 + RenderVertexSoft *v9; // ebx@4 + RenderVertexSoft *v10; // ecx@4 + float v11; // eax@6 + double v12; // ST5C_8@6 + double v13; // ST2C_8@6 + int v14; // eax@6 + double v15; // st7@6 + stru148 *v16; // ebx@12 + unsigned __int16 v17; // ax@12 + int v18; // eax@13 + LightmapBuilder *v19; // ecx@13 + stru220 *v20; // eax@13 + int v21; // eax@13 + signed int v22; // eax@13 + Vec3_float_ *v23; // eax@15 + double v24; // st6@17 + double v25; // ST54_8@17 + unsigned __int8 v26; // sf@17 + unsigned __int8 v27; // of@17 + double v28; // st5@19 + double v29; // st5@19 + double v30; // st5@19 + double v31; // st5@19 + double v32; // st7@32 + int v33; // edi@38 + unsigned int v34; // ecx@47 + char v35; // zf@47 + unsigned int v36; // eax@50 + int v37; // eax@54 + stru148 *v38; // ecx@55 + unsigned int v39; // eax@59 + stru148 *v40; // ebx@62 + unsigned __int16 v41; // ax@62 + int v42; // eax@63 + LightmapBuilder *v43; // ecx@63 + stru220 *v44; // eax@63 + int v45; // eax@63 + int v46; // eax@63 + signed int v47; // eax@63 + Vec3_float_ *v48; // eax@65 + double v49; // st6@67 + double v50; // ST4C_8@67 + double v51; // st5@71 + double v52; // st5@71 + double v53; // st5@71 + double v54; // st7@84 + unsigned int v55; // ecx@98 + unsigned int v56; // eax@101 + int v57; // eax@105 + unsigned int v58; // eax@109 + stru148 *v59; // esi@112 + unsigned __int16 v60; // ax@112 + stru220 *v61; // eax@113 + signed int v62; // eax@113 + Vec3_float_ *v63; // eax@114 + double v64; // st6@116 + double v65; // ST3C_8@116 + double v66; // st5@120 + double v67; // st5@120 + double v68; // st5@120 + double v69; // st7@133 + int v70; // edi@138 + RenderVertexSoft *v71; // esi@147 + unsigned int v72; // ecx@147 + unsigned int v73; // eax@150 + float v74; // eax@154 + unsigned int v75; // eax@158 + unsigned int v76; // [sp-10h] [bp-E0h]@61 + stru148 *v77; // [sp-Ch] [bp-DCh]@61 + IDirect3DTexture2 *v78; // [sp-8h] [bp-D8h]@61 + int v79; // [sp-4h] [bp-D4h]@61 + int v80; // [sp+0h] [bp-D0h]@59 + int v81; // [sp+0h] [bp-D0h]@109 + int v82; // [sp+54h] [bp-7Ch]@1 + int v83; // [sp+60h] [bp-70h]@1 + int v84; // [sp+6Ch] [bp-64h]@1 + int v85; // [sp+70h] [bp-60h]@63 + int a4; // [sp+74h] [bp-5Ch]@73 + float v87; // [sp+78h] [bp-58h]@122 + int v88; // [sp+7Ch] [bp-54h]@1 + int v89; // [sp+80h] [bp-50h]@6 + float v90; // [sp+84h] [bp-4Ch]@1 + float v91; // [sp+88h] [bp-48h]@1 + float v92; // [sp+8Ch] [bp-44h]@1 + stru220 *v93; // [sp+90h] [bp-40h]@2 + int X; // [sp+94h] [bp-3Ch]@1 + float v95; // [sp+98h] [bp-38h]@21 + LightmapBuilder *v96; // [sp+9Ch] [bp-34h]@73 + LightmapBuilder *_this; // [sp+A0h] [bp-30h]@6 + int sX; // [sp+A4h] [bp-2Ch]@6 + unsigned int uNumVertices; // [sp+A8h] [bp-28h]@73 + int v100; // [sp+ACh] [bp-24h]@122 + int sY; // [sp+B0h] [bp-20h]@6 + RenderVertexSoft *a2; // [sp+B4h] [bp-1Ch]@3 + unsigned int a5; // [sp+B8h] [bp-18h]@21 + RenderVertexSoft *v101; // [sp+BCh] [bp-14h]@6 + Vec3_float_ *v99; // [sp+C0h] [bp-10h]@17 + RenderVertexSoft *pVertices; // [sp+C4h] [bp-Ch]@6 + RenderVertexSoft *a8; // [sp+C8h] [bp-8h]@6 + char v108; // [sp+CFh] [bp-1h]@36 + float thisd; // [sp+D8h] [bp+8h]@6 + float thise; // [sp+D8h] [bp+8h]@6 + float thisf; // [sp+D8h] [bp+8h]@17 + IndoorCameraD3D *thisa; // [sp+D8h] [bp+8h]@23 + float thisg; // [sp+D8h] [bp+8h]@67 + IndoorCameraD3D *thisb; // [sp+D8h] [bp+8h]@75 + float thish; // [sp+D8h] [bp+8h]@116 + IndoorCameraD3D *thisc; // [sp+D8h] [bp+8h]@124 + char this_3; // [sp+DBh] [bp+Bh]@30 + char this_3a; // [sp+DBh] [bp+Bh]@82 + char this_3b; // [sp+DBh] [bp+Bh]@131 + + v3 = a1; + v82 = edx0; + v83 = *(/*short **/_WORD *)(a3 + 4); + X = abs(*(/*short **/_WORD *)(a3 + 6)); + v4 = 0; + v88 = 0; + v84 = v3 - 1; + v90 = (double)pOutdoor->vSunlight.x * 0.000015258789; + v91 = (double)pOutdoor->vSunlight.y * 0.000015258789; + v92 = (double)pOutdoor->vSunlight.z * 0.000015258789; + if ( v3 - 1 > 0 ) + { + while ( 1 ) + { + v5 = abs(X);//v5 = 13108 + v6 = abs(v83);//v6 = 13108 + --X; + v93 = &stru_76E5C8[(v5 << 7) + v6]; + if ( !v93->field_0 || ((v7 = 48 * v4, v8 = &pVerticesSR_806210[v4], a2 = v8, !v82) ? (v9 = (RenderVertexSoft *)((char *)&pVerticesSR_801A10 + v7), + v10 = &pVerticesSR_806210[1] + v7) : (v9 = &pVerticesSR_806210[1] + v7, v10 = (RenderVertexSoft *)((char *)&pVerticesSR_801A10 + v7)), + ((a8 = v9, + pVertices = &pVerticesSR_801A10[1] + v7, + v11 = v8->vWorldPosition.x, + v101 = v10, + v12 = v11 + 6.755399441055744e15, + sX = LODWORD(v12), + v13 = v8->vWorldPosition.y + 6.755399441055744e15, + sY = LODWORD(v13), + thisd = (v10->vWorldPosition.x + v8->vWorldPosition.x) * 0.5, + v14 = WorldPosToGridCellX(floorf(thisd + 0.5f)), + v15 = v9->vWorldPosition.y + v8->vWorldPosition.y, + v89 = v14, + thise = v15 * 0.5, + _this = (LightmapBuilder *)WorldPosToGridCellZ(floorf(thisd + 0.5f)), + WorldPosToGridCellX(sX), + WorldPosToGridCellZ(sY), + !byte_4D864C) + || !(pGame->uFlags & 0x80)) + && !sub_481EFA(v8, v9, v101, pVertices, 1)) ) + goto LABEL_162; + if ( v8->vWorldPosition.z != v9->vWorldPosition.z || v9->vWorldPosition.z != pVertices->vWorldPosition.z || pVertices->vWorldPosition.z != v101->vWorldPosition.z ) + break; + v16 = &array_77EC08[pOutdoorCamera->numStru148s]; + v17 = pOutdoor->GetTileTexture(sX, sY); + v16->uTileBitmapID = v17; + if ( v17 != -1 ) + { + v18 = pOutdoor->GetSomeOtherTileInfo(sX, sY); + LOWORD(v18) = v18 | 0x8010; + v19 = _this; + *(int *)&v16->flags = v18; + v20 = v93; + v16->field_59 = 1; + v16->field_5D = (char)v19; + v16->field_34 = v20->distance; + v21 = v89; + v16->field_5C = v89; + v22 = pTerrainNormalIndices[2 * (signed int)((char *)v19 + 128 * v21) + 1]; + if ( v22 < 0 || v22 > (signed int)(uNumTerrainNormals - 1) ) + v23 = 0; + else + v23 = &pTerrainNormals[v22]; + v24 = v92 * v23->z; + v99 = v23; + thisf = 20.0 - (-v24 - v91 * v23->y - v90 * v23->x) * 20.0; + v25 = thisf + 6.7553994e15; + v27 = pOutdoorCamera->numStru148s > 1999; + v26 = pOutdoorCamera->numStru148s - 1999 < 0; + v16->field_58 = LOBYTE(v25); + if ( !(v26 ^ v27) ) + return; + ++pOutdoorCamera->numStru148s; + if ( !sub_481FC9(v8, a8, v101, v16) ) + goto LABEL_126; + v28 = 1.0 / (a2->vWorldViewPosition.x + 0.0000001); + memcpy(array_50AC10, a2, 0x30u); + array_50AC10[0].flt_20 = v28; + array_50AC10[0].u = 0.0; + array_50AC10[0].v = 0.0; + v29 = a8->vWorldViewPosition.x + 0.0000001; + memcpy(&array_50AC10[1], a8, sizeof(array_50AC10[1])); + array_50AC10[1].flt_20 = 1.0 / v29; + array_50AC10[1].u = 0.0; + array_50AC10[1].v = 1.0; + v30 = pVertices->vWorldViewPosition.x + 0.0000001; + memcpy(&array_50AC10[2], pVertices, sizeof(array_50AC10[2])); + array_50AC10[2].flt_20 = 1.0 / v30; + array_50AC10[2].u = 1.0; + array_50AC10[2].v = 1.0; + v31 = v101->vWorldViewPosition.x + 0.0000001; + memcpy(&array_50AC10[3], v101, sizeof(array_50AC10[3])); + array_50AC10[3].flt_20 = 1.0 / v31; + array_50AC10[3].u = 1.0; + array_50AC10[3].v = 0.0; + + static stru154 static_sub_0048034E_stru_154; + /*static bool __init_flag3 = false; + if (!__init_flag3) + { + __init_flag3 = true; + + stru154::stru154(&static_sub_0048034E_stru_154); + }*/ + + _this = pGame->pLightmapBuilder; + pGame->pLightmapBuilder->StackLights_TerrainFace(v99, &v95, array_50AC10, 4u, 1); + pDecalBuilder->_49BE8A(v16, *(float *)&v99, (int)&v95, array_50AC10, 4u, 1); + a5 = 4; + if ( byte_4D864C && pGame->uFlags & 0x80 ) + { + thisa = pGame->pIndoorCameraD3D; + if ( pGame->pIndoorCameraD3D->_4371C3(array_50AC10, &a5, 0) == 1 && !a5 ) + goto LABEL_162; + thisa->ViewTransform(array_50AC10, a5); + thisa->Project(array_50AC10, a5, 0); + } + this_3 = a2->vWorldViewPosition.x < 8.0 + || a8->vWorldViewPosition.x < 8.0 + || v101->vWorldViewPosition.x < 8.0 + || pVertices->vWorldViewPosition.x < 8.0; + v32 = (double)pOutdoorCamera->shading_dist_mist; + v108 = v32 < a2->vWorldViewPosition.x + || v32 < a8->vWorldViewPosition.x + || v32 < v101->vWorldViewPosition.x + || v32 < pVertices->vWorldViewPosition.x; + LOBYTE(v33) = 0; + pGame->pLightmapBuilder->std__vector_000004_size = 0; + if ( stru_F8AD28.uNumLightsApplied > 0 || pDecalBuilder->uNumDecals > 0 ) + { + if ( this_3 ) + LOBYTE(v33) = 3; + else + v33 = v108 != 0 ? 5 : 0; + static_sub_0048034E_stru_154._49B0C9(v99, v95); + if ( pDecalBuilder->uNumDecals > 0 ) + pDecalBuilder->ApplyDecals( + 31 - v16->field_58, + 4, + &static_sub_0048034E_stru_154, + a5, + array_50AC10, + 0, + v33, + -1); + } + if ( stru_F8AD28.uNumLightsApplied > 0 ) + pGame->pLightmapBuilder->ApplyLights(&stru_F8AD28, &static_sub_0048034E_stru_154, a5, array_50AC10, 0, v33); + v34 = a5; + v35 = byte_4D864C == 0; + v16->uNumVertices = a5; + if ( v35 || !(pGame->uFlags & 0x80) ) + { + if ( this_3 ) + { + v36 = sr_424CD7(v34); + goto LABEL_53; + } + if ( v108 ) + { + v36 = sr_424EE0_MakeFanFromTriangle(v34); +LABEL_53: + v16->uNumVertices = v36; + OutdoorCamera::Project(v36); + } + } + v37 = *(int *)&v16->flags; + if ( !(BYTE1(v37) & 1) ) + { + if ( v37 & 2 && v16->uTileBitmapID == pRenderer->field_1036AC_bitmapid ) + { + v80 = 0; + v39 = pRenderer->pHDWaterBitmapIDs[pRenderer->field_1036A8_bitmapid]; + } + else + { + v39 = v16->uTileBitmapID; + v80 = 1; + } + v79 = 0; + v78 = pBitmaps_LOD->pHardwareTextures[v39]; + v77 = v16; + v76 = v16->uNumVertices; +LABEL_161: + pRenderer->DrawTerrainPolygon(v76, v77, v78, v79, v80); + goto LABEL_162; + } + v38 = v16; +LABEL_56: + v38->_4811A3(); + } +LABEL_162: + v4 = v88++ + 1; + if ( v88 >= v84 ) + return; + } + v40 = &array_77EC08[pOutdoorCamera->numStru148s]; + v41 = pOutdoor->GetTileTexture(sX, sY); + v40->uTileBitmapID = v41; + if ( v41 == -1 ) + goto LABEL_162; + v42 = pOutdoor->GetSomeOtherTileInfo(sX, sY); + BYTE1(v42) |= 0x80u; + v43 = pGame->pLightmapBuilder; + *(int *)&v40->flags = v42; + v44 = v93; + v40->field_59 = 1; + v40->field_5D = (char)v43; + v40->field_34 = v44->distance; + v45 = v89; + v40->field_5C = v89; + v46 = 2 * (int)((char *)v43 + 128 * v45); + v85 = v46 * 2; + v47 = pTerrainNormalIndices[v46 + 1]; + if ( v47 < 0 || v47 > (signed int)(uNumTerrainNormals - 1) ) + v48 = 0; + else + v48 = &pTerrainNormals[v47]; + v49 = v92 * v48->z; + v99 = v48; + thisg = 20.0 - (-v49 - v91 * v48->y - v90 * v48->x) * 20.0; + v50 = thisg + 6.7553994e15; + v40->field_58 = LOBYTE(v50); + if ( SLOBYTE(v50) < 0 ) + v40->field_58 = 0; + if ( pOutdoorCamera->numStru148s >= 1999 ) + return; + ++pOutdoorCamera->numStru148s; + if ( !sub_481FC9(a8, pVertices, v8, v40) ) + goto LABEL_77; + v51 = 1.0 / (a2->vWorldViewPosition.x + 0.0000001); + memcpy(array_50AC10, a2, 0x30u); + array_50AC10[0].flt_20 = v51; + array_50AC10[0].u = 0.0; + array_50AC10[0].v = 0.0; + v52 = a8->vWorldViewPosition.x + 0.0000001; + memcpy(&array_50AC10[1], a8, sizeof(array_50AC10[1])); + array_50AC10[1].flt_20 = 1.0 / v52; + array_50AC10[1].u = 0.0; + array_50AC10[1].v = 1.0; + v53 = pVertices->vWorldViewPosition.x + 0.0000001; + memcpy(&array_50AC10[2], pVertices, sizeof(array_50AC10[2])); + array_50AC10[2].flt_20 = 1.0 / v53; + array_50AC10[2].u = 1.0; + array_50AC10[2].v = 1.0; + + static stru154 static_sub_0048034E_stru_76D590; + /*static bool __init_flag2 = false; + if (!__init_flag2) + { + __init_flag2 = true; + + stru154::stru154(&static_sub_0048034E_stru_76D590); + }*/ + + v96 = pGame->pLightmapBuilder; + pGame->pLightmapBuilder->StackLights_TerrainFace(v99, (float *)&a4, array_50AC10, 3u, 0); + pDecalBuilder->_49BE8A(v40, *(float *)&v99, (int)&a4, array_50AC10, 3u, 0); + uNumVertices = 3; + if ( byte_4D864C && pGame->uFlags & 0x80 ) + { + thisb = pGame->pIndoorCameraD3D; + if ( pGame->pIndoorCameraD3D->_4371C3(array_50AC10, &uNumVertices, 0) == 1 && !uNumVertices ) + { +LABEL_77: + --pOutdoorCamera->numStru148s; + goto LABEL_112; + } + thisb->ViewTransform(array_50AC10, uNumVertices); + thisb->Project(array_50AC10, uNumVertices, 0); + } + this_3a = a2->vWorldViewPosition.x < 8.0 || a8->vWorldViewPosition.x < 8.0 || pVertices->vWorldViewPosition.x < 8.0; + v54 = (double)pOutdoorCamera->shading_dist_mist; + v108 = v54 < a2->vWorldViewPosition.x || v54 < a8->vWorldViewPosition.x || v54 < pVertices->vWorldViewPosition.x; + a8 = 0; + v96->std__vector_000004_size = 0; + if ( stru_F8AD28.uNumLightsApplied > 0 || pDecalBuilder->uNumDecals > 0 ) + { + a8 = (RenderVertexSoft *)(this_3a ? 3 : v108 != 0 ? 5 : 0); + static_sub_0048034E_stru_76D590._49B0C9(v99, *(float *)&a4); + if ( pDecalBuilder->uNumDecals > 0 ) + pDecalBuilder->ApplyDecals( + 31 - v40->field_58, + 4, + &static_sub_0048034E_stru_76D590, + uNumVertices, + array_50AC10, + 0, + (char)a8, + -1); + } + if ( stru_F8AD28.uNumLightsApplied > 0 ) + v96->ApplyLights( + &stru_F8AD28, + &static_sub_0048034E_stru_76D590, + uNumVertices, + array_50AC10, + 0, + (char)a8); + v55 = uNumVertices; + v35 = byte_4D864C == 0; + v40->uNumVertices = uNumVertices; + if ( v35 || !(pGame->uFlags & 0x80) ) + { + if ( this_3a ) + { + v56 = sr_424CD7(v55); + } + else + { + if ( !v108 ) + goto LABEL_105; + v56 = sr_424EE0_MakeFanFromTriangle(v55); + } + v40->uNumVertices = v56; + OutdoorCamera::Project(v56); + } +LABEL_105: + v57 = *(int *)&v40->flags; + if ( BYTE1(v57) & 1 ) + { + v40->_4811A3(); + } + else + { + if ( v57 & 2 && v40->uTileBitmapID == pRenderer->field_1036AC_bitmapid ) + { + v81 = 0; + v58 = pRenderer->pHDWaterBitmapIDs[pRenderer->field_1036A8_bitmapid]; + } + else + { + v58 = v40->uTileBitmapID; + v81 = 1; + } + pRenderer->DrawTerrainPolygon(v40->uNumVertices, v40, pBitmaps_LOD->pHardwareTextures[v58], 0, v81); + } +LABEL_112: + v59 = &array_77EC08[pOutdoorCamera->numStru148s]; + a8 = (RenderVertexSoft *)&array_77EC08[pOutdoorCamera->numStru148s]; + v60 = pOutdoor->GetTileTexture(sX, sY); + v59->uTileBitmapID = v60; + if ( v60 == -1 ) + goto LABEL_162; + *(int *)&v59->flags = pOutdoor->GetSomeOtherTileInfo(sX, sY); + v61 = v93; + v59->field_59 = 1; + v59->field_34 = v61->distance; + v59->field_5C = v89; + v59->field_5D = (char)_this; + v62 = *(unsigned __int16 *)((char *)pTerrainNormalIndices + v85); + if ( v62 > (signed int)(uNumTerrainNormals - 1) ) + v63 = 0; + else + v63 = &pTerrainNormals[v62]; + v64 = v92 * v63->z; + v99 = v63; + thish = 20.0 - (-v64 - v91 * v63->y - v90 * v63->x) * 20.0; + v65 = thish + 6.7553994e15; + v59->field_58 = LOBYTE(v65); + if ( SLOBYTE(v65) < 0 ) + v59->field_58 = 0; + if ( pOutdoorCamera->numStru148s >= 1999 ) + return; + ++pOutdoorCamera->numStru148s; + if ( !sub_481FC9(v101, a2, pVertices, v59) ) + { +LABEL_126: + --pOutdoorCamera->numStru148s; + goto LABEL_162; + } + v66 = 1.0 / (a2->vWorldViewPosition.x + 0.0000001); + memcpy(array_50AC10, a2, 0x30u); + array_50AC10[0].flt_20 = v66; + array_50AC10[0].u = 0.0; + array_50AC10[0].v = 0.0; + v67 = pVertices->vWorldViewPosition.x + 0.0000001; + memcpy(&array_50AC10[1], pVertices, sizeof(array_50AC10[1])); + array_50AC10[1].flt_20 = 1.0 / v67; + array_50AC10[1].u = 1.0; + array_50AC10[1].v = 1.0; + v68 = v101->vWorldViewPosition.x + 0.0000001; + memcpy(&array_50AC10[2], v101, sizeof(array_50AC10[2])); + array_50AC10[2].flt_20 = 1.0 / v68; + array_50AC10[2].u = 1.0; + array_50AC10[2].v = 0.0; + + static stru154 static_sub_0048034E_stru_76D578; + /*static bool __init_flag1 = false; + if (!__init_flag1) + { + __init_flag1 = true; + + stru154::stru154(&static_sub_0048034E_stru_76D578); + }*/ + + v96 = pGame->pLightmapBuilder; + pGame->pLightmapBuilder->StackLights_TerrainFace(v99, &v87, array_50AC10, 3u, 1); + pDecalBuilder->_49BE8A(v40, *(float *)&v99, (int)&v87, array_50AC10, 3u, 1); + v100 = 3; + if ( byte_4D864C && pGame->uFlags & 0x80 ) + { + thisc = pGame->pIndoorCameraD3D; + if ( pGame->pIndoorCameraD3D->_4371C3(array_50AC10, (unsigned int *)&v100, 0) == 1 && !v100 ) + goto LABEL_126; + thisc->ViewTransform(array_50AC10, v100); + thisc->Project(array_50AC10, v100, 0); + } + this_3b = a2->vWorldViewPosition.x < 8.0 + || pVertices->vWorldViewPosition.x < 8.0 + || v101->vWorldViewPosition.x < 8.0; + v69 = (double)pOutdoorCamera->shading_dist_mist; + v108 = v69 < a2->vWorldViewPosition.x || v69 < pVertices->vWorldViewPosition.x || v69 < v101->vWorldViewPosition.x; + LOBYTE(v70) = 0; + v96->std__vector_000004_size = 0; + if ( stru_F8AD28.uNumLightsApplied > 0 || pDecalBuilder->uNumDecals > 0 ) + { + if ( this_3b ) + LOBYTE(v70) = 3; + else + v70 = v108 != 0 ? 5 : 0; + static_sub_0048034E_stru_76D578._49B0C9(v99, v87); + if ( pDecalBuilder->uNumDecals > 0 ) + pDecalBuilder->ApplyDecals( + 31 - v40->field_58, + 4, + &static_sub_0048034E_stru_76D578, + v100, + array_50AC10, + 0, + v70, + -1); + } + if ( stru_F8AD28.uNumLightsApplied > 0 ) + v96->ApplyLights(&stru_F8AD28, &static_sub_0048034E_stru_76D578, v100, array_50AC10, 0, v70); + v71 = a8; + v72 = v100; + v35 = byte_4D864C == 0; + LODWORD(a8->vWorldViewPosition.z) = v100; + if ( !v35 && pGame->uFlags & 0x80 ) + goto LABEL_154; + if ( this_3b ) + { + v73 = sr_424CD7(v72); + } + else + { + if ( !v108 ) + { +LABEL_154: + v74 = v71[1].vWorldPosition.x; + if ( !(BYTE1(v74) & 1) ) + { + if ( LOBYTE(v74) & 2 && LOWORD(v71[1].vWorldViewProjY) == pRenderer->field_1036AC_bitmapid ) + { + v80 = 0; + v75 = pRenderer->pHDWaterBitmapIDs[pRenderer->field_1036A8_bitmapid]; + } + else + { + v75 = LOWORD(v71[1].vWorldViewProjY); + v80 = 1; + } + v79 = 0; + v78 = pBitmaps_LOD->pHardwareTextures[v75]; + v77 = (stru148 *)v71; + v76 = LODWORD(v71->vWorldViewPosition.z); + goto LABEL_161; + } + v38 = (stru148 *)v71; + goto LABEL_56; + } + v73 = sr_424EE0_MakeFanFromTriangle(v72); + } + LODWORD(v71->vWorldViewPosition.z) = v73; + OutdoorCamera::Project(v73); + goto LABEL_154; + } +} +// 47F44B: using guessed type int __stdcall WorldPosToGridCellX(int); +// 47F458: using guessed type int __stdcall WorldPosToGridCellZ(int); +// 4D864C: using guessed type char byte_4D864C; +// 76D5C0: using guessed type char static_sub_0048034E_byte_76D5C0__init_flag; + + + +//----- (00481212) -------------------------------------------------------- +void Render::DrawTerrainSW(int a1, int a2, int a3) +{ + int v3; // esi@1 + int v4; // ecx@1 + int v5; // ST10_4@1 + int v6; // edi@1 + int v7; // ebx@2 + int v8; // eax@2 + int v9; // eax@3 + RenderVertexSoft *v10; // edi@3 + RenderVertexSoft *v11; // ebx@4 + RenderVertexSoft *v12; // ecx@4 + float v13; // eax@6 + int v14; // eax@6 + double v15; // st7@6 + double v16; // st7@6 + stru148 *v17; // ebx@12 + unsigned __int16 v18; // ax@12 + int v19; // eax@13 + float v20; // ecx@13 + stru220 *v21; // eax@13 + int v22; // eax@13 + signed int v23; // eax@13 + Vec3_float_ *v24; // eax@15 + double v25; // st7@18 + double v26; // st5@24 + double v27; // st5@24 + double v28; // st5@24 + double v29; // st5@24 + Game *v30; // eax@25 + RenderVertexSoft *v31; // edi@29 + double v32; // st7@31 + int v33; // esi@35 + RenderVertexSoft *v34; // edx@36 + RenderVertexSoft *v35; // ecx@36 + signed int v36; // eax@39 + signed int v37; // esi@40 + stru148 *v38; // ebx@43 + unsigned __int16 v39; // ax@43 + int v40; // eax@44 + float v41; // ecx@44 + stru220 *v42; // eax@44 + int v43; // eax@44 + int v44; // eax@44 + signed int v45; // eax@44 + Vec3_float_ *v46; // eax@46 + double v47; // st7@49 + double v48; // st5@57 + double v49; // st5@57 + double v50; // st5@57 + Game *v51; // eax@58 + RenderVertexSoft *v52; // edi@62 + double v53; // st7@63 + int v54; // esi@66 + signed int v55; // eax@69 + signed int v56; // esi@71 + unsigned __int16 v57; // ax@75 + stru220 *v58; // eax@76 + signed int v59; // eax@76 + Vec3_float_ *v60; // eax@77 + double v61; // st7@80 + double v62; // st5@88 + double v63; // st5@88 + double v64; // st5@88 + Game *v65; // eax@89 + double v66; // st7@94 + RenderVertexSoft *v67; // [sp-Ch] [bp-C4h]@36 + stru148 *v68; // [sp-8h] [bp-C0h]@36 + int v69; // [sp-4h] [bp-BCh]@36 + float v70; // [sp+Ch] [bp-ACh]@88 + double v71; // [sp+10h] [bp-A8h]@6 + double v72; // [sp+18h] [bp-A0h]@82 + double v73; // [sp+20h] [bp-98h]@6 + double v74; // [sp+28h] [bp-90h]@51 + double v75; // [sp+30h] [bp-88h]@6 + double v76; // [sp+38h] [bp-80h]@20 + double v77; // [sp+40h] [bp-78h]@6 + float v78; // [sp+48h] [bp-70h]@57 + float v79; // [sp+4Ch] [bp-6Ch]@6 + float v80; // [sp+50h] [bp-68h]@6 + int v81; // [sp+54h] [bp-64h]@1 + int v82; // [sp+58h] [bp-60h]@6 + int v83; // [sp+5Ch] [bp-5Ch]@82 + int v84; // [sp+60h] [bp-58h]@20 + int v85; // [sp+64h] [bp-54h]@1 + int v86; // [sp+68h] [bp-50h]@1 + int v87; // [sp+6Ch] [bp-4Ch]@51 + float v88; // [sp+70h] [bp-48h]@51 + int v89; // [sp+74h] [bp-44h]@6 + int v90; // [sp+78h] [bp-40h]@1 + float a3a; // [sp+7Ch] [bp-3Ch]@24 + stru220 *v92; // [sp+80h] [bp-38h]@2 + float v93; // [sp+84h] [bp-34h]@44 + int v94; // [sp+88h] [bp-30h]@6 + float v95; // [sp+8Ch] [bp-2Ch]@1 + float v96; // [sp+90h] [bp-28h]@1 + float v97; // [sp+94h] [bp-24h]@1 + int X; // [sp+98h] [bp-20h]@1 + float v99; // [sp+9Ch] [bp-1Ch]@6 + int v100; // [sp+A0h] [bp-18h]@6 + unsigned __int64 v101; // [sp+A4h] [bp-14h]@6 + RenderVertexSoft *v102; // [sp+ACh] [bp-Ch]@6 + RenderVertexSoft *v103; // [sp+B0h] [bp-8h]@6 + RenderVertexSoft *v104; // [sp+B4h] [bp-4h]@3 + float pNormalc; // [sp+C0h] [bp+8h]@6 + float pNormald; // [sp+C0h] [bp+8h]@6 + Vec3_float_ *pNormal; // [sp+C0h] [bp+8h]@17 + Vec3_float_ *pNormala; // [sp+C0h] [bp+8h]@48 + Vec3_float_ *pNormalb; // [sp+C0h] [bp+8h]@77 + + v3 = a1; + //v4 = *(short *)(a3 + 4); + //v5 = *(short *)(a3 + 6); + v85 = a2; + v86 = *(_WORD *)(a3 + 4); //v4; + X = abs(*(_WORD *)(a3 + 6)); //v5 + v6 = 0; + v90 = 0; + v81 = v3 - 1; + v95 = (double)pOutdoor->vSunlight.x * 0.000015258789; + v96 = (double)pOutdoor->vSunlight.y * 0.000015258789; + v97 = (double)pOutdoor->vSunlight.z * 0.000015258789; + if ( v3 - 1 > 0 ) + { + while ( 1 ) + { + v7 = abs(X); + v8 = abs(v86); + --X; + v92 = &stru_76E5C8[(v7 << 7) + v8]; + if ( !v92->field_0 + || ((v9 = v6, v10 = &pVerticesSR_806210[v6], v104 = v10, !v85) ? (v11 = &pVerticesSR_801A10[v9], + v12 = &pVerticesSR_806210[v9 + 1]) : (v11 = &pVerticesSR_806210[v9 + 1], v12 = &pVerticesSR_801A10[v9]), + ((v103 = &pVerticesSR_801A10[v9 + 1], + v13 = v10->vWorldPosition.x, + v102 = v12, + v80 = v13, + v73 = v13 + 6.7553994e15, + v101 = __PAIR__((unsigned int)v11, LODWORD(v73)), + v79 = v10->vWorldPosition.y, + v75 = v79 + 6.7553994e15, + v100 = LODWORD(v75), + pNormalc = (v12->vWorldPosition.x + v10->vWorldPosition.x) * 0.5, + v71 = pNormalc + 6.7553994e15, + v89 = LODWORD(v71), + v14 = WorldPosToGridCellX(COERCE_UNSIGNED_INT64(pNormalc + 6.7553994e15)), + v15 = v11->vWorldPosition.y + v10->vWorldPosition.y, + v94 = v14, + pNormald = v15 * 0.5, + v16 = pNormald + 6.7553994e15, + v77 = v16, + v82 = LODWORD(v77), + LODWORD(v99) = WorldPosToGridCellZ(LODWORD(v16)), + WorldPosToGridCellX(v101), + WorldPosToGridCellZ(v100), + !byte_4D864C) + || !(pGame->uFlags & 0x80)) + && !sub_481EFA(v10, v11, v102, v103, 1)) ) + goto LABEL_105; + if ( v10->vWorldPosition.z != v11->vWorldPosition.z + || v11->vWorldPosition.z != v103->vWorldPosition.z + || v103->vWorldPosition.z != v102->vWorldPosition.z ) + break; + v17 = &array_77EC08[pOutdoorCamera->numStru148s]; + v18 = pOutdoor->GetTileTexture(v101, v100); + v17->uTileBitmapID = v18; + if ( v18 != -1 ) + { + v19 = pOutdoor->GetSomeOtherTileInfo(v101, v100); + LOWORD(v19) = v19 | 0x8010; + v20 = v99; + *(int *)&v17->flags = v19; + v21 = v92; + v17->field_59 = 1; + v17->field_5D = LOBYTE(v20); + v17->field_34 = v21->distance; + v22 = v94; + v17->field_5C = v94; + v23 = pTerrainNormalIndices[2 * (LODWORD(v20) + (v22 << 7)) + 1]; + if ( v23 < 0 || v23 > (signed int)(uNumTerrainNormals - 1) ) + v24 = 0; + else + v24 = &pTerrainNormals[v23]; + pNormal = v24; + if ( v24 ) + { + v25 = -(v97 * v24->z + v96 * v24->y + v95 * v24->x); + if ( v25 < 0.0 ) + v25 = 0.0; + v99 = v25 * 31.0; + v76 = v99 + 6.7553994e15; + v84 = LODWORD(v76); + v17->field_58 = 31 - LOBYTE(v76); + } + else + { + v17->field_58 = 0; + } + if ( pOutdoorCamera->numStru148s >= 1999 ) + return; + ++pOutdoorCamera->numStru148s; + if ( !sub_481FC9(v10, (RenderVertexSoft *)HIDWORD(v101), v102, v17) ) + goto LABEL_104; + v26 = 1.0 / (v104->vWorldViewPosition.x + 0.0000001); + memcpy(array_50AC10, v104, 0x30u); + array_50AC10[0].flt_20 = v26; + array_50AC10[0].u = 0.0; + array_50AC10[0].v = 0.0; + v27 = *(float *)(HIDWORD(v101) + 12) + 0.0000001; + memcpy(&array_50AC10[1], (void *)HIDWORD(v101), sizeof(array_50AC10[1])); + array_50AC10[1].flt_20 = 1.0 / v27; + array_50AC10[1].u = 0.0; + array_50AC10[1].v = 1.0; + v28 = v103->vWorldViewPosition.x + 0.0000001; + memcpy(&array_50AC10[2], v103, sizeof(array_50AC10[2])); + array_50AC10[2].flt_20 = 1.0 / v28; + array_50AC10[2].u = 1.0; + array_50AC10[2].v = 1.0; + v29 = v102->vWorldViewPosition.x + 0.0000001; + memcpy(&array_50AC10[3], v102, sizeof(array_50AC10[3])); + array_50AC10[3].flt_20 = 1.0 / v29; + array_50AC10[3].u = 1.0; + array_50AC10[3].v = 0.0; + pGame->pLightmapBuilder->StackLights_TerrainFace(pNormal, &a3a, array_50AC10, 4u, 1); + if ( stru_F8AD28.uNumLightsApplied <= 0 ) + { + v17->field_108 = 0; + } + else + { + v30 = pGame; + v17->field_108 = 1; + pGame->pLightmapBuilder->_45CA88(&stru_F8AD28, array_50AC10, 4, pNormal); + } + if ( v104->vWorldViewPosition.x < 8.0 + || *(float *)(HIDWORD(v101) + 12) < 8.0 + || (v31 = v102, v102->vWorldViewPosition.x < 8.0) + || v103->vWorldViewPosition.x < 8.0 ) + { + v36 = sr_4250FE(4u); + } + else + { + v32 = (double)pOutdoorCamera->shading_dist_mist; + if ( v32 >= v104->vWorldViewPosition.x + && v32 >= *(float *)(HIDWORD(v101) + 12) + && v32 >= v102->vWorldViewPosition.x + && v32 >= v103->vWorldViewPosition.x ) + { + v33 = sr_4254D2(4); + v17->uNumVertices = v33; + if ( !v33 ) + goto LABEL_104; + v34 = (RenderVertexSoft *)HIDWORD(v101); + v35 = v104; + v69 = 0; + v68 = v17; + v67 = v31; + goto LABEL_37; + } + v36 = sr_4252E8(4u); + } + v37 = v36; + if ( !v36 ) + goto LABEL_104; +LABEL_41: + OutdoorCamera::Project(v37); +LABEL_102: + v33 = sr_4254D2(v37); + v17->uNumVertices = v33; + if ( !v33 ) + goto LABEL_104; + v17->_48276F_sr(); + goto LABEL_38; + } +LABEL_105: + v6 = v90++ + 1; + if ( v90 >= v81 ) + return; + } + v38 = &array_77EC08[pOutdoorCamera->numStru148s]; + v39 = pOutdoor->GetTileTexture(v101, v100); + v38->uTileBitmapID = v39; + if ( v39 == -1 ) + goto LABEL_105; + v40 = pOutdoor->GetSomeOtherTileInfo(v101, v100); + BYTE1(v40) |= 0x80u; + v41 = v99; + *(int *)&v38->flags = v40; + v42 = v92; + v38->field_59 = 1; + v38->field_5D = LOBYTE(v41); + v38->field_34 = v42->distance; + v43 = v94; + v38->field_5C = v94; + v44 = 2 * (LODWORD(v41) + (v43 << 7)); + LODWORD(v93) = v44 * 2; + v45 = pTerrainNormalIndices[v44 + 1]; + if ( v45 < 0 || v45 > (signed int)(uNumTerrainNormals - 1) ) + v46 = 0; + else + v46 = &pTerrainNormals[v45]; + pNormala = v46; + if ( v46 ) + { + v47 = -(v97 * v46->z + v96 * v46->y + v95 * v46->x); + if ( v47 < 0.0 ) + v47 = 0.0; + v88 = v47 * 31.0; + v74 = v88 + 6.7553994e15; + v87 = LODWORD(v74); + v38->field_58 = 31 - LOBYTE(v74); + } + else + { + v38->field_58 = 0; + } + if ( v38->field_58 < 0 ) + v38->field_58 = 0; + if ( pOutdoorCamera->numStru148s >= 1999 ) + return; + ++pOutdoorCamera->numStru148s; + if ( !sub_481FC9((RenderVertexSoft *)HIDWORD(v101), v103, v104, v38) ) + goto LABEL_74; + v48 = 1.0 / (v104->vWorldViewPosition.x + 0.0000001); + memcpy(array_50AC10, v104, 0x30u); + array_50AC10[0].flt_20 = v48; + array_50AC10[0].u = 0.0; + array_50AC10[0].v = 0.0; + v49 = *(float *)(HIDWORD(v101) + 12) + 0.0000001; + memcpy(&array_50AC10[1], (void *)HIDWORD(v101), sizeof(array_50AC10[1])); + array_50AC10[1].flt_20 = 1.0 / v49; + array_50AC10[1].u = 0.0; + array_50AC10[1].v = 1.0; + v50 = v103->vWorldViewPosition.x + 0.0000001; + memcpy(&array_50AC10[2], v103, sizeof(array_50AC10[2])); + array_50AC10[2].flt_20 = 1.0 / v50; + array_50AC10[2].u = 1.0; + array_50AC10[2].v = 1.0; + pGame->pLightmapBuilder->StackLights_TerrainFace(pNormala, &v78, array_50AC10, 3u, 0); + if ( stru_F8AD28.uNumLightsApplied <= 0 ) + { + v38->field_108 = 0; + } + else + { + v51 = pGame; + v38->field_108 = 1; + pGame->pLightmapBuilder->_45CA88(&stru_F8AD28, array_50AC10, 3, pNormala); + } + if ( v104->vWorldViewPosition.x < 8.0 + || *(float *)(HIDWORD(v101) + 12) < 8.0 + || (v52 = v103, v103->vWorldViewPosition.x < 8.0) ) + { + v55 = sr_4250FE(3u); + } + else + { + v53 = (double)pOutdoorCamera->shading_dist_mist; + if ( v53 >= v104->vWorldViewPosition.x + && v53 >= *(float *)(HIDWORD(v101) + 12) + && v53 >= v103->vWorldViewPosition.x ) + { + v54 = sr_4254D2(3); + v38->uNumVertices = v54; + if ( v54 ) + { + sr_sub_4829B9((RenderVertexSoft *)HIDWORD(v101), v52, v104, v38, 0); +LABEL_68: + sr_sub_481DB2(array_508690, v54, v38); +LABEL_75: + v17 = &array_77EC08[pOutdoorCamera->numStru148s]; + v57 = pOutdoor->GetTileTexture(v101, v100); + v17->uTileBitmapID = v57; + if ( v57 == -1 ) + goto LABEL_105; + *(int *)&v17->flags = pOutdoor->GetSomeOtherTileInfo(v101, v100); + v58 = v92; + v17->field_59 = 1; + v17->field_34 = v58->distance; + v17->field_5C = v94; + v17->field_5D = LOBYTE(v99); + v59 = *(unsigned __int16 *)((char *)pTerrainNormalIndices + LODWORD(v93)); + if ( v59 > (signed int)(uNumTerrainNormals - 1) ) + { + pNormalb = 0; + v60 = 0; + } + else + { + v60 = &pTerrainNormals[v59]; + pNormalb = v60; + } + if ( v60 ) + { + v61 = -(v97 * v60->z + v96 * v60->y + v95 * v60->x); + if ( v61 < 0.0 ) + v61 = 0.0; + v93 = v61 * 31.0; + v72 = v93 + 6.7553994e15; + v83 = LODWORD(v72); + v17->field_58 = 31 - LOBYTE(v72); + } + else + { + v17->field_58 = 0; + } + if ( v17->field_58 < 0 ) + v17->field_58 = 0; + if ( pOutdoorCamera->numStru148s >= 1999 ) + return; + ++pOutdoorCamera->numStru148s; + if ( !sub_481FC9(v102, v104, v103, v17) ) + { +LABEL_104: + --pOutdoorCamera->numStru148s; + goto LABEL_105; + } + v62 = 1.0 / (v104->vWorldViewPosition.x + 0.0000001); + memcpy(array_50AC10, v104, 0x30u); + array_50AC10[0].flt_20 = v62; + array_50AC10[0].u = 0.0; + array_50AC10[0].v = 0.0; + v63 = v103->vWorldViewPosition.x + 0.0000001; + memcpy(&array_50AC10[1], v103, sizeof(array_50AC10[1])); + array_50AC10[1].flt_20 = 1.0 / v63; + array_50AC10[1].u = 1.0; + array_50AC10[1].v = 1.0; + v64 = v102->vWorldViewPosition.x + 0.0000001; + memcpy(&array_50AC10[2], v102, sizeof(array_50AC10[2])); + array_50AC10[2].flt_20 = 1.0 / v64; + array_50AC10[2].u = 1.0; + array_50AC10[2].v = 0.0; + pGame->pLightmapBuilder->StackLights_TerrainFace(pNormalb, &v70, array_50AC10, 3u, 1); + if ( stru_F8AD28.uNumLightsApplied <= 0 ) + { + v17->field_108 = 0; + } + else + { + v65 = pGame; + v17->field_108 = 1; + pGame->pLightmapBuilder->_45CA88(&stru_F8AD28, array_50AC10, 3, pNormalb); + } + if ( v104->vWorldViewPosition.x < 8.0 || v103->vWorldViewPosition.x < 8.0 || v102->vWorldViewPosition.x < 8.0 ) + { + v37 = sr_4250FE(3u); + OutdoorCamera::Project(v37); + if ( !v37 ) + goto LABEL_104; + goto LABEL_102; + } + v66 = (double)pOutdoorCamera->shading_dist_mist; + if ( v66 < v104->vWorldViewPosition.x || v66 < v103->vWorldViewPosition.x || v66 < v102->vWorldViewPosition.x ) + { + v37 = sr_4252E8(3u); + if ( !v37 ) + goto LABEL_105; + goto LABEL_41; + } + v33 = sr_4254D2(3); + v17->uNumVertices = v33; + if ( !v33 ) + goto LABEL_104; + v34 = v104; + v35 = v102; + v69 = 0; + v68 = v17; + v67 = v103; +LABEL_37: + sr_sub_4829B9(v35, v34, v67, v68, v69); +LABEL_38: + sr_sub_481DB2(array_508690, v33, v17); + goto LABEL_105; + } + goto LABEL_74; + } + v55 = sr_4252E8(3u); + } + v56 = v55; + if ( v55 ) + { + OutdoorCamera::Project(v55); + v54 = sr_4254D2(v56); + v38->uNumVertices = v54; + if ( v54 ) + { + v38->_48276F_sr(); + goto LABEL_68; + } + } +LABEL_74: + --pOutdoorCamera->numStru148s; + goto LABEL_75; + } +} +// 47F44B: using guessed type int __stdcall WorldPosToGridCellX(int); +// 47F458: using guessed type int __stdcall WorldPosToGridCellZ(int); +// 4D864C: using guessed type char byte_4D864C; + + +//----- (0047BACF) -------------------------------------------------------- +void Render::TransformBillboardsAndSetPalettesODM() +{ + int v0; // edi@1 + char *v1; // esi@2 + unsigned int v2; // edx@3 + int v3; // eax@3 + int v4; // edi@3 + int v5; // eax@3 + __int16 v6; // di@3 + int v7; // eax@3 + int v8; // ebx@4 + unsigned __int16 *v9; // eax@7 + char v10; // zf@9 + DWORD v11; // eax@13 + int v12; // eax@13 + int v13; // eax@14 + RenderBillboardTransform_local0 billboard; // [sp+4h] [bp-60h]@1 + int v15; // [sp+54h] [bp-10h]@13 + int v16; // [sp+58h] [bp-Ch]@1 + int v17; // [sp+5Ch] [bp-8h]@2 + int v18; // [sp+60h] [bp-4h]@13 + + billboard.uParentBillboardID = -1; + billboard.pTarget = pRenderer->pTargetSurface; + billboard.pTargetZ = pRenderer->pActiveZBuffer; + billboard.uTargetPitch = pRenderer->uTargetSurfacePitch; + billboard.uViewportX = pViewport->uViewportX; + billboard.uViewportY = pViewport->uViewportY; + billboard.uViewportZ = pViewport->uViewportZ - 1; + billboard.uViewportW = pViewport->uViewportW; + v0 = 0; + pOutdoorCamera->uNumBillboards = uNumBillboardsToDraw; + v16 = 0; + if ( (signed int)uNumBillboardsToDraw > 0 ) + { + v17 = 0; + v1 = (char *)&pBillboardRenderList[0].uScreenSpaceY; + do + { + billboard.uScreenSpaceX = *((short *)v1 - 1); + v2 = *((short *)v1 - 5); + billboard.uScreenSpaceY = *(short *)v1; + v3 = *((int *)v1 - 10); + billboard.uParentBillboardID = v0; + v4 = *((int *)v1 + 1); + billboard.field_10 = v3; + v5 = *((int *)v1 - 9); + billboard.uTintColor = v4; + v6 = *((short *)v1 - 8); + billboard.field_14 = v5; + v7 = *((int *)v1 - 6); + billboard.sZValue = *((int *)v1 - 6); + billboard.uFlags = v2; + if ( v6 != -1 ) + { + v8 = *((short *)v1 + 1); + if ( pRenderer->pRenderD3D ) + { + billboard.sZValue = v7; + billboard.uFlags = v2; + pRenderer->TransformBillboard( + &billboard, + &pSprites_LOD->pHardwareSprites[v6], + v8, + (RenderBillboard *)(v1 - 40)); + } + else + { + if ( *(v1 - 10) & 2 ) + v9 = PaletteManager::Get_Dark_or_Red_LUT(*((short *)v1 - 7), 0, 1); + else + v9 = GetBillboardPalette((RenderBillboard *)(v1 - 40), *((short *)v1 - 7), v7, *((short *)v1 + 1)); + v10 = (*(v1 - 9) & 1) == 0; + billboard.pPalette = v9; + if ( !v10 ) + billboard.pPalette = pPaletteManager->field_261600[*((short *)v1 - 7)]; + if ( !(billboard.uFlags & 0x40) && billboard.uFlags & 0x80 ) + { + v11 = GetTickCount(); + v12 = stru_5C6E00->SinCos(v17 + v11); + v15 = abs(v12); + v18 = (unsigned __int64)(15i64 * v15) >> 16; + billboard.pPalette2 = PaletteManager::Get_Dark_or_Red_LUT(*((short *)v1 - 7), 15 - v18, 1); + } + v13 = *((short *)v1 - 8); + if ( v13 >= 0 ) + pSprites_LOD->pSpriteHeaders[v13]._4ACC38(&billboard, 1); + } + } + v17 += 5; + v0 = v16 + 1; + v1 += 52; + ++v16; + } + while ( v16 < (signed int)uNumBillboardsToDraw ); + } +} + + +//----- (0047AF11) -------------------------------------------------------- +void Render::DrawLayingItems_Shooting_Magic_ODM() +{ + char *v0; // edi@2 + ObjectDesc *v1; // ebx@4 + __int16 v2; // cx@5 + RenderBillboard *v3; // esi@10 + SpriteFrame *v4; // eax@10 + SpriteFrame *v5; // ebx@10 + unsigned int v6; // eax@10 + int v7; // ecx@10 + int v8; // edx@10 + int v9; // ecx@10 + unsigned __int16 v10; // ax@10 + int *v11; // eax@14 + int v12; // eax@22 + int v13; // ST3C_4@23 + int v14; // eax@23 + int v15; // ecx@23 + int v16; // ebx@23 + int v17; // ecx@25 + int v18; // eax@25 + int v19; // ST40_4@26 + int v20; // ecx@26 + int v21; // ST44_4@28 + int v22; // ST3C_4@29 + signed __int64 v23; // qtt@30 + int v24; // ebx@30 + int v25; // ST3C_4@30 + int v26; // eax@31 + char v27; // zf@31 + SpriteFrame *v28; // [sp+Ch] [bp-34h]@10 + __int16 a5; // [sp+10h] [bp-30h]@10 + int v30; // [sp+14h] [bp-2Ch]@23 + int v31; // [sp+14h] [bp-2Ch]@29 + __int16 v32; // [sp+14h] [bp-2Ch]@30 + int v33; // [sp+18h] [bp-28h]@23 + int v34; // [sp+18h] [bp-28h]@26 + int v35; // [sp+18h] [bp-28h]@30 + int v36; // [sp+1Ch] [bp-24h]@10 + int v37; // [sp+1Ch] [bp-24h]@23 + int a6; // [sp+20h] [bp-20h]@10 + int a6a; // [sp+20h] [bp-20h]@23 + int v40; // [sp+24h] [bp-1Ch]@25 + signed int v41; // [sp+28h] [bp-18h]@1 + int v42; // [sp+2Ch] [bp-14h]@23 + int y; // [sp+30h] [bp-10h]@10 + int x; // [sp+34h] [bp-Ch]@10 + int z; // [sp+38h] [bp-8h]@10 + signed __int16 v46; // [sp+3Ch] [bp-4h]@12 + + v41 = 0; + if ( (signed int)uNumLayingItems > 0 ) + { + v0 = (char *)&pLayingItems[0].uSectorID; + do + { + if ( *((short *)v0 - 13) ) + { + v1 = &pObjectList->pObjects[*((short *)v0 - 13)]; + if ( !(v1->uFlags & 1) ) + { + if ( ((v2 = *((short *)v0 - 14), v2 < 1000) || v2 >= 10000) && (v2 < 500 || v2 >= 600) + || pGame->pStru6Instance->_4A81CA((LayingItem *)(v0 - 28)) ) + { + a5 = *(short *)v0; + x = *((int *)v0 - 6); + y = *((int *)v0 - 5); + z = *((int *)v0 - 4); + v3 = &pBillboardRenderList[uNumBillboardsToDraw]; + v4 = pSpriteFrameTable->GetFrame(v1->uSpriteID, *((short *)v0 + 1)); + v5 = v4; + v28 = v4; + v36 = v4->uFlags; + a6 = v4->uGlowRadius * *((short *)v0 + 3); + v6 = stru_5C6E00->Atan2( + *((int *)v0 - 6) - pIndoorCamera->pos.x, + *((int *)v0 - 5) - pIndoorCamera->pos.y); + LOWORD(v7) = *((short *)v0 - 3); + v8 = v36; + v9 = ((signed int)(stru_5C6E00->uIntegerPi + ((signed int)stru_5C6E00->uIntegerPi >> 3) + v7 - v6) >> 8) & 7; + v10 = v5->pHwSpriteIDs[v9]; + v3->uHwSpriteID = v10; + if ( v36 & 0x20 ) + { + v8 = v36; + z -= (signed int)((unsigned __int64)(v5->scale + * (signed __int64)pSprites_LOD->pSpriteHeaders[(signed __int16)v10].uHeight) >> 16) >> 1; + } + v46 = 0; + if ( v8 & 2 ) + v46 = 2; + v11 = (int *)(256 << v9); + if ( (256 << v9) & v8 ) + v46 |= 4u; + if ( v8 & 0x40000 ) + v46 |= 0x40u; + if ( v8 & 0x20000 ) + LOBYTE(v46) = v46 | 0x80; + if ( a6 ) + { + LOBYTE(v11) = byte_4E94D3; + pMobileLightsStack->AddLight(x, y, z, a5, a6, 0xFFu, 0xFFu, 0xFFu, byte_4E94D3); + } + v12 = (x - pIndoorCamera->pos.x) << 16; + if ( pIndoorCamera->sRotationX ) + { + v13 = (y - pIndoorCamera->pos.y) << 16; + v30 = ((unsigned __int64)(v12 * (signed __int64)pOutdoorCamera->camera_rotation_y_int_cosine) >> 16) + + ((unsigned __int64)(v13 * (signed __int64)pOutdoorCamera->camera_rotation_y_int_sine) >> 16); + v37 = (unsigned __int64)(v12 * (signed __int64)pOutdoorCamera->camera_rotation_y_int_sine) >> 16; + a6a = (unsigned __int64)(v13 * (signed __int64)pOutdoorCamera->camera_rotation_y_int_cosine) >> 16; + v33 = (z - pIndoorCamera->pos.z) << 16; + v14 = (unsigned __int64)(v30 * (signed __int64)pOutdoorCamera->camera_rotation_x_int_cosine) >> 16; + v15 = (unsigned __int64)(v33 * (signed __int64)pOutdoorCamera->camera_rotation_x_int_sine) >> 16; + v16 = v15 + v14; + v42 = v15 + v14; + if ( v15 + v14 >= 262144 && v16 <= pOutdoorCamera->shading_dist_mist << 16 ) + { + v17 = a6a - v37; + v40 = a6a - v37; + v18 = ((unsigned __int64)(v33 * (signed __int64)pOutdoorCamera->camera_rotation_x_int_cosine) >> 16) + - ((unsigned __int64)(v30 * (signed __int64)pOutdoorCamera->camera_rotation_x_int_sine) >> 16); + goto LABEL_29; + } + } + else + { + v34 = (y - pIndoorCamera->pos.y) << 16; + v19 = (unsigned __int64)(v12 * (signed __int64)pOutdoorCamera->camera_rotation_y_int_cosine) >> 16; + v20 = (unsigned __int64)(v34 * (signed __int64)pOutdoorCamera->camera_rotation_y_int_sine) >> 16; + v16 = v20 + v19; + v42 = v20 + v19; + if ( v20 + v19 >= 262144 && v16 <= pOutdoorCamera->shading_dist_mist << 16 ) + { + v21 = (unsigned __int64)(((x - pIndoorCamera->pos.x) << 16) + * (signed __int64)pOutdoorCamera->camera_rotation_y_int_sine) >> 16; + v17 = ((unsigned __int64)(v34 * (signed __int64)pOutdoorCamera->camera_rotation_y_int_cosine) >> 16) + - v21; + v40 = ((unsigned __int64)(v34 * (signed __int64)pOutdoorCamera->camera_rotation_y_int_cosine) >> 16) + - v21; + v18 = (z - pIndoorCamera->pos.z) << 16; +LABEL_29: + v31 = v18; + v22 = abs(v17); + if ( abs(v16) >= v22 ) + { + LODWORD(v23) = 0; + HIDWORD(v23) = SLOWORD(pOutdoorCamera->int_fov_rad); + v24 = v23 / v42; + v25 = v23 / v42; + LODWORD(v23) = 0; + HIDWORD(v23) = SLOWORD(pOutdoorCamera->int_fov_rad); + v35 = pViewport->uScreenCenterX + - ((signed int)(((unsigned __int64)(v25 * (signed __int64)v40) >> 16) + 32768) >> 16); + v32 = LOWORD(pViewport->uScreenCenterY) + - (((unsigned int)((unsigned __int64)(v23 / v42 * v31) >> 16) + 32768) >> 16); + if ( (signed int)uNumBillboardsToDraw >= 500 ) + return; + ++uNumBillboardsToDraw; + ++uNumSpritesDrawnThisFrame; + *(v0 - 2) |= 1u; + v3->uPalette = v28->uPaletteIndex; + v3->uIndoorSectorID = a5; + v3->field_0 = (unsigned __int64)(v28->scale * (signed __int64)v24) >> 16; + v26 = (unsigned __int64)(v28->scale * (signed __int64)v24) >> 16; + v3->pSpriteFrame = v28; + v3->field_4 = v26; + v3->field_1E = v46; + v3->some_x = x; + v3->some_y = y; + v3->some_z = z; + v3->uScreenSpaceX = v35; + v3->uScreenSpaceY = v32; + HIWORD(v26) = HIWORD(v42); + LOWORD(v26) = 0; + v27 = (*(v0 - 2) & 0x20) == 0; + v3->sZValue = v26 + (8 * v41 | 2); + v3->uPaletteSubindex = 0; + v3->uTintColor = 0; + if ( !v27 ) + { + if ( !pRenderer->pRenderD3D ) + v3->sZValue = 0; + } + } + goto LABEL_34; + } + } + } + } + } +LABEL_34: + ++v41; + v0 += 112; + } + while ( v41 < (signed int)uNumLayingItems ); + } +} +// 4E94D3: using guessed type char byte_4E94D3; +// 5187E4: using guessed type int uNumSpritesDrawnThisFrame; + + +//----- (0049D9BC) -------------------------------------------------------- +signed int __stdcall RenderD3D__DeviceEnumerator(GUID *lpGUID, const char *lpDevDesc, const char *lpDriverName, RenderD3D__DevInfo *pOut) +{ + size_t v4; // eax@1 + size_t v5; // eax@1 + IUnknown *v6; // eax@10 + size_t v7; // eax@13 + DDDEVICEIDENTIFIER ddDevId; // [sp+4h] [bp-4F8h]@11 + DDSURFACEDESC2 v10;/*int v10; // [sp+42Ch] [bp-D0h]@16 + int v11; // [sp+430h] [bp-CCh]@16 + int v12; // [sp+434h] [bp-C8h]@16 + int v13; // [sp+438h] [bp-C4h]@16 + int v14; // [sp+474h] [bp-88h]@16*/ + DDSCAPS2 ddsCaps; // [sp+4A8h] [bp-54h]@14 + unsigned int uFreeVideoMem; // [sp+4B8h] [bp-44h]@14 + RenderD3D_aux aux; // [sp+4BCh] [bp-40h]@19 + IDirect3D3 *pDirect3D3; // [sp+4C4h] [bp-38h]@18 + int v19; // [sp+4C8h] [bp-34h]@16 + RenderD3D_D3DDevDesc v20; // [sp+4CCh] [bp-30h]@1 + LPDIRECTDRAW pDirectDraw; // [sp+4F4h] [bp-8h]@4 + IDirectDraw4 *pDirectDraw4; // [sp+4F8h] [bp-4h]@7 + + v4 = strlen(lpDriverName); + v20.pDriverName = new char[v4 + 1]; + v5 = strlen(lpDevDesc); + v20.pDeviceDesc = new char[v5 + 1]; + strcpy(v20.pDriverName, lpDriverName); + strcpy(v20.pDeviceDesc, lpDevDesc); + if ( lpGUID ) + { + v20.pGUID = new GUID; + memcpy(v20.pGUID, lpGUID, 0x10u); + } + else + { + v20.pGUID = 0; + } + + if (FAILED(DirectDrawCreate(v20.pGUID, &pDirectDraw, 0))) + { + delete [] v20.pDriverName; + delete [] v20.pDeviceDesc; + if ( v20.pGUID ) + delete v20.pGUID; + } + else + { + if (FAILED(pDirectDraw->QueryInterface(IID_IDirectDraw4, (LPVOID *)&pDirectDraw4))) + { + delete [] v20.pDriverName; + delete [] v20.pDeviceDesc; + if ( v20.pGUID ) + delete v20.pGUID; + v6 = (IUnknown *)pDirectDraw; + } + else + { + pDirectDraw->Release(); + if (FAILED( pDirectDraw4->GetDeviceIdentifier(&ddDevId, 1u))) + { + v20.pDDraw4DevDesc = 0; + } + else + { + v7 = strlen(ddDevId.szDescription); + v20.pDDraw4DevDesc = new char[v7 + 1]; + strcpy(v20.pDDraw4DevDesc, ddDevId.szDescription); + } + memset(&ddsCaps, 0, 0x10u); + if (FAILED(pDirectDraw4->GetAvailableVidMem( + &ddsCaps, + (LPDWORD)&v20.uVideoMem, + (LPDWORD)&uFreeVideoMem))) + v20.uVideoMem = 0; + memset(&v10, 0, 0x7Cu); + v10.dwSize = 124; + v10.dwFlags = 6; + v10.dwHeight = 640; + v10.dwWidth = 480; + v10.ddpfPixelFormat.dwSize = 32; + + v19 = 0; + if ( FAILED(pDirectDraw4->EnumDisplayModes( + 0, + 0, + &v19, + (LPDDENUMMODESCALLBACK2)DDrawDisplayModesEnumerator)) + || !v19 + || FAILED(pDirectDraw4->QueryInterface(IID_IDirect3D3, (LPVOID *)&pDirect3D3))) + { + delete [] v20.pDriverName; + delete [] v20.pDeviceDesc; + if ( v20.pDDraw4DevDesc ) + free(v20.pDDraw4DevDesc); + if ( v20.pGUID ) + delete v20.pGUID; + v6 = (IUnknown *)pDirectDraw4; + } + else + { + aux.pInfo = pOut; + aux.ptr_4 = &v20; + pDirect3D3->EnumDevices((LPD3DENUMDEVICESCALLBACK)D3DDeviceEnumerator, &aux); + delete [] v20.pDriverName; + delete [] v20.pDeviceDesc; + if ( v20.pDDraw4DevDesc ) + free(v20.pDDraw4DevDesc); + if ( v20.pGUID ) + delete v20.pGUID; + pDirectDraw4->Release(); + v6 = (IUnknown *)pDirect3D3; + pDirectDraw4 = 0; + } + } + v6->Release(); + } + return 1; +} + + +//----- (0049D784) -------------------------------------------------------- +HRESULT __stdcall D3DDeviceEnumerator(const GUID *lpGUID, const char *lpDeviceDesc, const char *lpDeviceName, D3DDEVICEDESC *pHWDesc, D3DDEVICEDESC *pSWDesc, RenderD3D_aux *a6) +{ + int v6; // eax@1 + signed int v7; // edi@1 + signed int v8; // edi@14 + size_t v9; // eax@30 + size_t v10; // eax@30 + size_t v11; // eax@30 + size_t v12; // eax@30 + size_t v13; // eax@30 + + v6 = pHWDesc->dwFlags; + v7 = -1; + if ( v6 ) + { + if ( !a6->ptr_4->pGUID ) + v7 = 0; + if ( v6 && a6->ptr_4->pGUID ) + v7 = 1; + } + if ( !strcmp(lpDeviceName, "RGB Emulation") && !a6->ptr_4->pGUID ) + v7 = 2; + if ( !strcmp(lpDeviceName, "Reference Rasterizer") && !a6->ptr_4->pGUID ) + v7 = 3; + if ( v7 != -1 ) + { + v8 = v7; + a6->pInfo[v8].bIsDeviceCompatible = 1; + a6->pInfo[v8].uCaps = 0; + if ( !(pHWDesc->dpcTriCaps.dwSrcBlendCaps & 0x10) ) + a6->pInfo[v8].uCaps |= 2u; + if ( !(pHWDesc->dpcTriCaps.dwSrcBlendCaps & 2) ) + a6->pInfo[v8].uCaps |= 4u; + if ( !(pHWDesc->dpcTriCaps.dwSrcBlendCaps & 1) ) + a6->pInfo[v8].uCaps |= 8u; + if ( !(pHWDesc->dpcTriCaps.dwDestBlendCaps & 0x20) ) + a6->pInfo[v8].uCaps |= 0x10u; + if ( !(pHWDesc->dpcTriCaps.dwDestBlendCaps & 2) ) + a6->pInfo[v8].uCaps |= 0x20u; + if ( !(pHWDesc->dpcTriCaps.dwDestBlendCaps & 4) ) + a6->pInfo[v8].uCaps |= 0x40u; + if ( !(BYTE1(pHWDesc->dwDevCaps) & 0x10) ) + BYTE1(a6->pInfo[v8].uCaps) |= 1u; + if ( pHWDesc->dpcTriCaps.dwTextureCaps & 0x20 ) + LOBYTE(a6->pInfo[v8].uCaps) |= 0x80u; + v9 = strlen(lpDeviceName); + a6->pInfo[v8].pName = new char[v9 + 1]; + strcpy(a6->pInfo[v8].pName, lpDeviceName); + v10 = strlen(lpDeviceDesc); + a6->pInfo[v8].pDescription = new char[v10 + 1]; + strcpy(a6->pInfo[v8].pDescription, lpDeviceDesc); + a6->pInfo[v8].pGUID = (GUID *)operator new(0x10u); + memcpy(a6->pInfo[v8].pGUID, lpGUID, 0x10u); + v11 = strlen(a6->ptr_4->pDriverName); + a6->pInfo[v8].pDriverName = new char[v11 + 1]; + strcpy(a6->pInfo[v8].pDriverName, a6->ptr_4->pDriverName); + v12 = strlen(a6->ptr_4->pDeviceDesc); + a6->pInfo[v8].pDeviceDesc = new char[v12 + 1]; + strcpy(a6->pInfo[v8].pDeviceDesc, a6->ptr_4->pDeviceDesc); + v13 = strlen(a6->ptr_4->pDDraw4DevDesc); + a6->pInfo[v8].pDDraw4DevDesc = new char[v13 + 1]; + strcpy(a6->pInfo[v8].pDDraw4DevDesc, a6->ptr_4->pDDraw4DevDesc); + if ( a6->ptr_4->pGUID ) + { + a6->pInfo[v8].pDirectDrawGUID = new GUID; + memcpy(a6->pInfo[v8].pDirectDrawGUID, a6->ptr_4->pGUID, 0x10u); + } + else + { + a6->pInfo[v8].pDirectDrawGUID = 0; + } + a6->pInfo[v8].uVideoMem = a6->ptr_4->uVideoMem; + } + return 1; +} + + +//----- (0049D75C) -------------------------------------------------------- +HRESULT __stdcall DDrawDisplayModesEnumerator(DDSURFACEDESC2 *pSurfaceDesc, __int16 *a2) +{ + HRESULT result; // eax@3 + + if ( pSurfaceDesc->ddsCaps.dwCaps | 0x2000 && pSurfaceDesc->ddpfPixelFormat.dwRGBBitCount == 16 ) + { + *a2 = 1; + result = 0; + } + else + { + result = 1; + } + return result; +} + + + +//----- (0047A95E) -------------------------------------------------------- +void Render::DrawDecorations() +{ + char *v0; // esi@2 + DecorationDesc *v1; // ebx@6 + __int16 v2; // ax@6 + double v3; // st7@7 + int v4; // eax@9 + int v5; // edx@9 + unsigned int v6; // edi@9 + int v7; // eax@9 + SpriteFrame *v8; // eax@9 + SpriteFrame *v9; // edi@9 + unsigned __int16 *v10; // eax@9 + int v11; // ecx@9 + int v12; // eax@9 + int v13; // ecx@9 + int v14; // ecx@20 + char v15; // dl@20 + signed int v16; // eax@20 + int v17; // eax@23 + int v18; // ecx@24 + int v19; // eax@24 + int v20; // ecx@24 + int v21; // ebx@26 + int v22; // eax@26 + int v23; // eax@30 + signed __int64 v24; // qtt@31 + int v25; // ebx@31 + int v26; // ecx@32 + RenderBillboard *v27; // eax@37 + __int16 v28; // dx@37 + __int16 v29; // cx@37 + int v30; // ecx@37 + int v31; // ebx@37 + Particle_ local_0; // [sp+Ch] [bp-98h]@7 + int x; // [sp+74h] [bp-30h]@9 + int y; // [sp+78h] [bp-2Ch]@9 + int v35; // [sp+7Ch] [bp-28h]@1 + int v36; // [sp+80h] [bp-24h]@9 + unsigned __int16 *v37; // [sp+84h] [bp-20h]@9 + int v38; // [sp+88h] [bp-1Ch]@9 + int v39; // [sp+8Ch] [bp-18h]@24 + int v40; // [sp+90h] [bp-14h]@24 + int v41; // [sp+94h] [bp-10h]@24 + int v42; // [sp+98h] [bp-Ch]@9 + int a5; // [sp+9Ch] [bp-8h]@9 + int b; // [sp+A0h] [bp-4h]@22 + + v35 = 0; + if ( (signed int)uNumLevelDecorations > 0 ) + { + v0 = (char *)&pLevelDecorations[0].vPosition.y; + do + { + if ( (!(*(v0 - 6) & 0x40) || ((LevelDecoration *)(v0 - 8))->_47A825()) && !(*(v0 - 6) & 0x20) ) + { + v1 = &pDecorationList->pDecorations[*((short *)v0 - 4)]; + v2 = v1->uFlags; + if ( (char)v2 >= 0 ) + { + if ( !(v2 & 0x22) ) + { + v4 = *((int *)v0 - 1); + v5 = *((int *)v0 + 1); + v6 = pMiscTimer->uTotalGameTimeElapsed; + y = *(int *)v0; + x = v4; + v36 = v5; + v7 = abs(v4 + y); + v8 = pSpriteFrameTable->GetFrame(v1->uSpriteID, v6 + v7); + v9 = v8; + v42 = v8->uFlags; + a5 = v8->uGlowRadius; + v10 = (unsigned __int16 *)stru_5C6E00->Atan2( + *((int *)v0 - 1) - pIndoorCamera->pos.x, + *(int *)v0 - pIndoorCamera->pos.y); + v11 = *((int *)v0 + 2); + v37 = v10; + v12 = v42; + v38 = 0; + v13 = ((signed int)(stru_5C6E00->uIntegerPi + + ((signed int)stru_5C6E00->uIntegerPi >> 3) + + v11 + - (signed int)v37) >> 8) & 7; + v37 = (unsigned __int16 *)v13; + if ( v42 & 2 ) + v38 = 2; + if ( (256 << v13) & v42 ) + v38 |= 4u; + if ( v12 & 0x40000 ) + v38 |= 0x40u; + if ( v12 & 0x20000 ) + LOBYTE(v38) = v38 | 0x80; + if ( a5 ) + { + if ( pRenderer->pRenderD3D && pRenderer->bUseColoredLights ) + { + v14 = v1->uColoredLightRed; + v15 = v1->uColoredLightGreen; + v16 = v1->uColoredLightBlue; + } + else + { + v16 = 255; + v14 = 255; + v15 = 255; + } + b = v16; + pStationaryLightsStack->AddLight( + x, + y, + v36 + v1->uDecorationHeight / 2, + a5, + v14, + v15, + v16, + byte_4E94D0); + } + v17 = (x - pIndoorCamera->pos.x) << 16; + if ( pIndoorCamera->sRotationX ) + { + v40 = (y - pIndoorCamera->pos.y) << 16; + v18 = ((unsigned __int64)(v17 * (signed __int64)pOutdoorCamera->camera_rotation_y_int_cosine) >> 16) + + ((unsigned __int64)(v40 * (signed __int64)pOutdoorCamera->camera_rotation_y_int_sine) >> 16); + v42 = v18; + b = (unsigned __int64)(v17 * (signed __int64)pOutdoorCamera->camera_rotation_y_int_sine) >> 16; + a5 = (unsigned __int64)(v40 * (signed __int64)pOutdoorCamera->camera_rotation_y_int_cosine) >> 16; + v40 = (v36 - pIndoorCamera->pos.z) << 16; + v41 = (unsigned __int64)(v40 * (signed __int64)pOutdoorCamera->camera_rotation_x_int_sine) >> 16; + v19 = (unsigned __int64)(v18 * (signed __int64)pOutdoorCamera->camera_rotation_x_int_cosine) >> 16; + v20 = v19 + ((unsigned __int64)(v40 * (signed __int64)pOutdoorCamera->camera_rotation_x_int_sine) >> 16); + v39 = v19 + ((unsigned __int64)(v40 * (signed __int64)pOutdoorCamera->camera_rotation_x_int_sine) >> 16); + if ( v20 >= 262144 && v20 <= pOutdoorCamera->shading_dist_mist << 16 ) + { + v21 = a5 - b; + v41 = a5 - b; + a5 = (unsigned __int64)(v42 * (signed __int64)pOutdoorCamera->camera_rotation_x_int_sine) >> 16; + b = (unsigned __int64)(v40 * (signed __int64)pOutdoorCamera->camera_rotation_x_int_cosine) >> 16; + v22 = ((unsigned __int64)(v40 * (signed __int64)pOutdoorCamera->camera_rotation_x_int_cosine) >> 16) - a5; +LABEL_30: + v42 = v22; + v40 = 2 * abs(v20); + v23 = abs(v21); + if ( v40 >= v23 ) + { + LODWORD(v24) = 0; + HIDWORD(v24) = SLOWORD(pOutdoorCamera->int_fov_rad); + a5 = v24 / v39; + v25 = pViewport->uScreenCenterX + - ((signed int)(((unsigned __int64)(v24 / v39 * v41) >> 16) + 32768) >> 16); + b = (unsigned __int64)(a5 * (signed __int64)v42) >> 16; + v41 = v24 / v39; + v40 = pViewport->uScreenCenterY + - ((signed int)(((unsigned __int64)(a5 * (signed __int64)v42) >> 16) + 32768) >> 16); + v42 = v9->scale; + v41 = (unsigned __int64)(v42 * v24 / v39) >> 16; + v37 = (unsigned __int16 *)&v9->pHwSpriteIDs[(int)v37]; + if ( pRenderer->pRenderD3D ) + { + v26 = v41; + v42 = pSprites_LOD->pHardwareSprites[(signed __int16)*v37].uBufferWidth >> 1; + b = (unsigned __int64)(v42 * (signed __int64)v41) >> 16; + } + else + { + v26 = v41; + v42 = pSprites_LOD->pSpriteHeaders[(signed __int16)*v37].uWidth >> 1; + b = (unsigned __int64)(v42 * (signed __int64)v41) >> 16; + } + if ( b + v25 >= (signed int)pViewport->uViewportX && v25 - b <= (signed int)pViewport->uViewportZ ) + { + if ( (signed int)uNumBillboardsToDraw >= 500 ) + return; + v27 = &pBillboardRenderList[uNumBillboardsToDraw++]; + ++uNumDecorationsDrawnThisFrame; + v27->uHwSpriteID = *v37; + v28 = v9->uPaletteIndex; + v27->field_0 = v26; + v27->field_4 = v26; + v29 = v38; + v27->uScreenSpaceX = v25; + HIBYTE(v29) |= 2u; + v27->uPalette = v28; + v27->field_1E = v29; + v27->some_x = x; + v27->some_y = y; + v27->some_z = v36; + v27->uScreenSpaceY = v40; + HIWORD(v30) = HIWORD(v39); + v31 = 8 * v35 | 5; + LOWORD(v30) = 0; + v27->uIndoorSectorID = 0; + v27->sZValue = v30 + v31; + v27->uPaletteSubindex = 0; + v27->pSpriteFrame = v9; + v27->uTintColor = 0; + } + } + goto LABEL_38; + } + } + else + { + v42 = (x - pIndoorCamera->pos.x) << 16; + v40 = (y - pIndoorCamera->pos.y) << 16; + b = (unsigned __int64)(v17 * (signed __int64)pOutdoorCamera->camera_rotation_y_int_cosine) >> 16; + a5 = (unsigned __int64)(v40 * (signed __int64)pOutdoorCamera->camera_rotation_y_int_sine) >> 16; + v20 = b + ((unsigned __int64)(v40 * (signed __int64)pOutdoorCamera->camera_rotation_y_int_sine) >> 16); + v39 = b + ((unsigned __int64)(v40 * (signed __int64)pOutdoorCamera->camera_rotation_y_int_sine) >> 16); + if ( v20 >= 262144 && v20 <= pOutdoorCamera->shading_dist_mist << 16 ) + { + a5 = (unsigned __int64)(v42 * (signed __int64)pOutdoorCamera->camera_rotation_y_int_sine) >> 16; + b = (unsigned __int64)(v40 * (signed __int64)pOutdoorCamera->camera_rotation_y_int_cosine) >> 16; + v21 = ((unsigned __int64)(v40 * (signed __int64)pOutdoorCamera->camera_rotation_y_int_cosine) >> 16) - a5; + v41 = ((unsigned __int64)(v40 * (signed __int64)pOutdoorCamera->camera_rotation_y_int_cosine) >> 16) - a5; + v22 = (v36 - pIndoorCamera->pos.z) << 16; + goto LABEL_30; + } + } + } + } + else + { + memset(&local_0, 0, 0x68u); + v3 = (double)*((signed int *)v0 - 1); + local_0.bFree = 1036; + local_0.uDiffuse = 0xFF3C1Eu; + local_0.x = v3; + local_0.y = (double)*(signed int *)v0; + local_0.z = (double)*((signed int *)v0 + 1); + local_0.flt_10 = 0.0; + local_0.flt_14 = 0.0; + local_0.flt_18 = 0.0; + local_0.flt_28 = 1.0; + local_0.timeToLive = (rand() & 0x80) + 128; + local_0.uTextureID = pBitmaps_LOD->LoadTexture("effpar01"); + pGame->pParticleEngine->AddParticle(&local_0); + } + } +LABEL_38: + ++v35; + v0 += 32; + } + while ( v35 < (signed int)uNumLevelDecorations ); + } +} +// 4E94D0: using guessed type char byte_4E94D0; +// 5187EC: using guessed type int uNumDecorationsDrawnThisFrame; + + +//----- (0049D717) -------------------------------------------------------- +HRESULT __stdcall D3DZBufferFormatEnumerator(DDPIXELFORMAT *Src, DDPIXELFORMAT *Dst) +{ + HRESULT v2; // esi@2 + + if ( Src->dwFlags & 0x400 | 0x2000 ) + { + v2 = 0; + if ( Src->dwRGBBitCount == 16 && !Src->dwRBitMask ) + goto LABEL_6; + if ( !Dst->dwSize ) + { + v2 = 1; +LABEL_6: + memcpy(Dst, Src, 0x20u); + return v2; + } + } + return 1; +} + +//----- (0049DC28) -------------------------------------------------------- +void RenderD3D::GetAvailableDevices(RenderD3D__DevInfo **pOutDevices) +{ + RenderD3D__DevInfo *v2; // eax@1 + + v2 = new RenderD3D__DevInfo[4];// 4 items + *pOutDevices = v2; + memset(v2, 0, 0xA0u); + DirectDrawEnumerateA((LPDDENUMCALLBACKA)RenderD3D__DeviceEnumerator, *pOutDevices); +} + + +//----- (0049DC58) -------------------------------------------------------- +RenderD3D::RenderD3D() +{ + RenderD3D *v1; // esi@1 + + v1 = this; + this->pHost = 0; + this->pDirect3D = 0; + this->pUnk = 0; + this->pBackBuffer = 0; + this->pFrontBuffer = 0; + this->pZBuffer = 0; + this->pDevice = 0; + this->pViewport = 0; + this->field_40 = 1; + this->field_44 = 10; + GetAvailableDevices(&this->pAvailableDevices); +} + +//----- (0049DC90) -------------------------------------------------------- +void RenderD3D::Release() +{ + RenderD3D *v1; // esi@1 + IDirectDraw4 *v2; // eax@2 + signed int v3; // edi@4 + IDirect3DViewport3 *v4; // eax@22 + IUnknown *v5; // eax@24 + IDirectDrawSurface4 *v6; // eax@26 + IDirect3DDevice3 *v7; // eax@28 + IDirect3D3 *v8; // eax@30 + IDirectDrawSurface4 *v9; // eax@32 + IDirectDrawSurface4 *v10; // eax@34 + IDirectDraw4 *v11; // eax@36 + + v1 = this; + if ( !this->bWindowed ) + { + v2 = this->pHost; + if ( v2 ) + { + v2->RestoreDisplayMode(); + v1->pHost->SetCooperativeLevel(v1->hWindow, 8u); + v1->pHost->FlipToGDISurface(); + } + } + v3 = 0; + do + { + if ( v1->pAvailableDevices[v3].pDriverName ) + { + free(v1->pAvailableDevices[v3].pDriverName); + v1->pAvailableDevices[v3].pDriverName = 0; + } + if ( v1->pAvailableDevices[v3].pDeviceDesc ) + { + free(v1->pAvailableDevices[v3].pDeviceDesc); + v1->pAvailableDevices[v3].pDeviceDesc = 0; + } + if ( v1->pAvailableDevices[v3].pDDraw4DevDesc ) + { + free(v1->pAvailableDevices[v3].pDDraw4DevDesc); + v1->pAvailableDevices[v3].pDDraw4DevDesc = 0; + } + if ( v1->pAvailableDevices[v3].pDirectDrawGUID ) + { + free(v1->pAvailableDevices[v3].pDirectDrawGUID); + v1->pAvailableDevices[v3].pDirectDrawGUID = 0; + } + if ( v1->pAvailableDevices[v3].pName ) + { + free(v1->pAvailableDevices[v3].pName); + v1->pAvailableDevices[v3].pName = 0; + } + if ( v1->pAvailableDevices[v3].pDescription ) + { + free(v1->pAvailableDevices[v3].pDescription); + v1->pAvailableDevices[v3].pDescription = 0; + } + if ( v1->pAvailableDevices[v3].pGUID ) + { + free(v1->pAvailableDevices[v3].pGUID); + v1->pAvailableDevices[v3].pGUID = 0; + } + ++v3; + } + while ( v3 < 4 ); + if ( v1->pAvailableDevices ) + { + free(v1->pAvailableDevices); + v1->pAvailableDevices = 0; + } + v4 = v1->pViewport; + if ( v4 ) + { + v4->Release(); + v1->pViewport = 0; + } + v5 = v1->pUnk; + if ( v5 ) + { + v5->Release(); + v1->pUnk = 0; + } + v6 = v1->pZBuffer; + if ( v6 ) + { + v6->Release(); + v1->pZBuffer = 0; + } + v7 = v1->pDevice; + if ( v7 ) + { + v7->Release(); + v1->pDevice = 0; + } + v8 = v1->pDirect3D; + if ( v8 ) + { + v8->Release(); + v1->pDirect3D = 0; + } + v9 = v1->pBackBuffer; + if ( v9 ) + { + v9->Release(); + v1->pBackBuffer = 0; + } + v10 = v1->pFrontBuffer; + if ( v10 ) + { + v10->Release(); + v1->pFrontBuffer = 0; + } + v11 = v1->pHost; + if ( v11 ) + { + v11->Release(); + v1->pHost = 0; + } +} + + +//----- (0049DE14) -------------------------------------------------------- +bool RenderD3D::CreateDevice(unsigned int uDeviceID, int bWindowed, HWND hWnd) +{ + //IDirectDraw4 *v8; // eax@12 + //IDirectDraw4 *v9; // eax@16 + //IDirectDraw4 *v10; // eax@20 + //IDirectDraw4 *v13; // eax@35 + const char *v23; // [sp-4h] [bp-DCh]@9 + const char *v24; // [sp-4h] [bp-DCh]@13 + const char *v25; // [sp-4h] [bp-DCh]@19 + DWORD v26; // [sp-4h] [bp-DCh]@30 + DDSCAPS2 v27; // [sp+Ch] [bp-CCh]@37 + 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 + + this->bWindowed = bWindowed; + this->hWindow = hWnd; + + if (FAILED(DirectDrawCreate(pAvailableDevices[uDeviceID].pDirectDrawGUID, &lpDD, 0))) + { + sprintf(pErrorMessage, "Init - Failed to create DirectDraw interface.\n"); + return 0; + } + + if (FAILED(lpDD->QueryInterface(IID_IDirectDraw4, (LPVOID *)&pHost))) + { + sprintf(pErrorMessage, "Init - Failed to create DirectDraw4 interface.\n"); + if (lpDD) + lpDD->Release(); + return 0; + } + lpDD->Release(); + lpDD = 0; + + if (bWindowed && !pAvailableDevices[uDeviceID].pDirectDrawGUID) + { + if (FAILED(pHost->SetCooperativeLevel(hWnd, DDSCL_MULTITHREADED | DDSCL_NORMAL))) + { + v23 = "Init - Failed to set cooperative level.\n"; + sprintf(pErrorMessage, v23); +LABEL_65: + if (pHost) + { + pHost->Release(); + pHost = 0; + } + return 0; + } + memset(&ddsd2, 0, sizeof(DDSURFACEDESC2)); + ddsd2.dwSize = sizeof(DDSURFACEDESC2); + ddsd2.dwFlags = DDSD_CAPS; + ddsd2.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; + if ( !pHost->CreateSurface(&ddsd2, &pFrontBuffer, 0) ) + { + ddsd2.dwSize = sizeof(DDSURFACEDESC2); + pHost->GetDisplayMode(&ddsd2); + if ( 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.dwHeight = 480; + if (pHost->CreateSurface(&ddsd2, &pBackBuffer, 0) ) + { + v24 = "Init - Failed to create back buffer.\n"; +LABEL_14: + sprintf(pErrorMessage, v24); + if (pFrontBuffer) + { + pFrontBuffer->Release(); + pFrontBuffer = 0; + } + goto LABEL_65; + } + if ( pHost->CreateClipper(0, &v30, 0) ) + { + v25 = "Init - Failed to create clipper.\n"; + goto LABEL_45; + } + v30->SetHWnd(0, hWnd); + pFrontBuffer->SetClipper(v30); + + v30->Release(); + v30 = 0; + + 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.dwHeight = 480; + + if ( pDirect3D->EnumZBufferFormats(*pAvailableDevices[uDeviceID].pGUID, + (HRESULT (__stdcall *)(DDPIXELFORMAT *, void *))D3DZBufferFormatEnumerator, + &ddsd2.ddpfPixelFormat) ) + goto LABEL_21; + if ( uDeviceID == 2 || uDeviceID == 3 ) + ddsd2.ddsCaps.dwCaps |= DDSCAPS_SYSTEMMEMORY; + + if ( !pHost->CreateSurface(&ddsd2, &pZBuffer, 0) ) + { + if ( !pBackBuffer->AddAttachedSurface(pZBuffer) ) + { + if ( !pDirect3D->CreateDevice(*pAvailableDevices[uDeviceID].pGUID, + pBackBuffer, + &pDevice, + 0) ) + { + memset(&d3dvp2, 0, sizeof(D3DVIEWPORT2)); + d3dvp2.dvClipWidth = 2.0; + d3dvp2.dvClipY = 1.0; + d3dvp2.dvClipHeight = 2.0; + d3dvp2.dvMaxZ = 1.0; + d3dvp2.dvMinZ = 0.0; + goto LABEL_54; + } +LABEL_51: + sprintf(pErrorMessage, "Init - Failed to create D3D device.\n"); + if (pDirect3D) + { + pDirect3D->Release(); + pDirect3D = 0; + } + goto LABEL_59; + } +LABEL_48: + sprintf(pErrorMessage, "Init - Failed to attach z-buffer to back buffer.\n"); + if (pZBuffer) + { + pZBuffer->Release(); + pZBuffer = 0; + } + goto LABEL_61; + } + goto LABEL_44; + } +LABEL_36: + v23 = "Init - Failed to create front buffer.\n"; + sprintf(pErrorMessage, v23); + goto LABEL_65; + } + if ( uDeviceID == 1 ) + v26 = 1045; + else + v26 = 1041; + if (pHost->SetCooperativeLevel(hWnd, v26) ) + { + v23 = "Init - Failed to set cooperative level.\n"; + sprintf(pErrorMessage, v23); + goto LABEL_65; + } + if (pHost->SetDisplayMode(640u, 480u, 16u, 0, 0) ) + { + v23 = "Init - Failed to set display mode.\n"; + sprintf(pErrorMessage, v23); + goto LABEL_65; + } + + memset(&ddsd2, 0, sizeof(DDSURFACEDESC2)); + ddsd2.dwSize = sizeof(DDSURFACEDESC2); + ddsd2.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT; + ddsd2.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_3DDEVICE | DDSCAPS_FLIP | DDSCAPS_COMPLEX; + ddsd2.dwBackBufferCount = 1; + if ( pHost->CreateSurface(&ddsd2, &pFrontBuffer, 0) ) + goto LABEL_36; + //a3a = &pBackBuffer; + //v14 = *v34; + memset(&v27, 0, sizeof(DDSCAPS2)); + v27.dwCaps = DDSCAPS_BACKBUFFER; + //v33 = (IDirect3DDevice3 **)v14->GetAttachedSurface(&v27, &pBackBuffer); + //hWnda = &pDirect3D; + pHost->QueryInterface(IID_IDirect3D3, (LPVOID *)&pDirect3D); + if (FAILED(pFrontBuffer->GetAttachedSurface(&v27, &pBackBuffer))) + { + v25 = "Init - Failed to get D3D interface.\n"; + goto LABEL_45; + } + + ddsd2.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT; + ddsd2.ddsCaps.dwCaps = DDSCAPS_ZBUFFER; + ddsd2.dwWidth = 640; + ddsd2.dwHeight = 480; + if ( pDirect3D->EnumZBufferFormats(*pAvailableDevices[uDeviceID].pGUID, + (HRESULT (__stdcall *)(DDPIXELFORMAT *, void *))D3DZBufferFormatEnumerator, + &ddsd2.ddpfPixelFormat) ) + { +LABEL_21: + v25 = "Init - Failed to enumerate Z buffer formats.\n"; + goto LABEL_45; + } + if ( uDeviceID == 2 || uDeviceID == 3 ) + BYTE1(ddsd2.ddsCaps.dwCaps) |= 8u; + //uDeviceIDa = &pZBuffer; + if (pHost->CreateSurface(&ddsd2, &pZBuffer, 0) ) + { +LABEL_44: + v25 = "Init - Failed to create z-buffer.\n"; +LABEL_45: + sprintf(pErrorMessage, v25); + if (pBackBuffer) + { + pBackBuffer->Release(); + pBackBuffer = 0; + } +LABEL_63: + //v19 = &pFrontBuffer; + if (pFrontBuffer) + { + pFrontBuffer->Release(); + pFrontBuffer= 0; + } + goto LABEL_65; + } + if (pBackBuffer->AddAttachedSurface(pZBuffer)) + goto LABEL_48; + //v33 = &pDevice; + if (pDirect3D->CreateDevice(*pAvailableDevices[uDeviceID].pGUID, + pBackBuffer, + &pDevice, + 0) ) + goto LABEL_51; + memset(&d3dvp2, 0, sizeof(D3DVIEWPORT2)); + d3dvp2.dvClipWidth = 2.0; + d3dvp2.dvClipY = 1.0; + d3dvp2.dvClipHeight = 2.0; + d3dvp2.dvMaxZ = 1.0; + +LABEL_54: + d3dvp2.dwSize = sizeof(D3DVIEWPORT2); + //v17 = *hWnda; + d3dvp2.dwWidth = 640; + d3dvp2.dwHeight = 480; + d3dvp2.dvClipX = -1.0; + //v18 = v17->lpVtbl; + //v32 = &v4->pViewport; + if (pDirect3D->CreateViewport(&pViewport, 0)) + { + sprintf(pErrorMessage, "Init - Failed to create viewport.\n"); + if (pDevice) + { + pDevice->Release(); + pDevice = 0; + } + if (pDirect3D) + { + pDirect3D->Release(); + pDirect3D = 0; + } +LABEL_59: + if (pZBuffer) + { + pZBuffer->Release(); + pZBuffer = 0; + } +LABEL_61: + if (pBackBuffer) + { + pBackBuffer->Release(); + pBackBuffer = 0; + } + goto LABEL_63; + } + + pDevice->AddViewport(pViewport); + pViewport->SetViewport2(&d3dvp2); + pDevice->SetCurrentViewport(pViewport); + return 1; +} + + +//----- (0049E444) -------------------------------------------------------- +unsigned int RenderD3D::GetDeviceCaps() +{ + unsigned int v1; // ebx@1 + RenderD3D *v2; // edi@1 + IDirect3DDevice3 *v3; // eax@1 + unsigned int result; // eax@2 + D3DDEVICEDESC refCaps; // [sp+Ch] [bp-1F8h]@1 + D3DDEVICEDESC halCaps; // [sp+108h] [bp-FCh]@1 + + v1 = 0; + v2 = this; + memset(&halCaps, 0, 0xFCu); + halCaps.dwSize = 252; + memset(&refCaps, 0, 0xFCu); + v3 = v2->pDevice; + refCaps.dwSize = 252; + if ( v3->GetCaps(&halCaps, &refCaps) ) + { + result = 1; + } + else + { + if ( !(halCaps.dpcTriCaps.dwSrcBlendCaps & 0x10) ) + v1 = 2; + if ( !(halCaps.dpcTriCaps.dwSrcBlendCaps & 2) ) + v1 |= 4u; + if ( !(halCaps.dpcTriCaps.dwSrcBlendCaps & 1) ) + v1 |= 8u; + if ( !(halCaps.dpcTriCaps.dwDestBlendCaps & 0x20) ) + v1 |= 0x10u; + if ( !(halCaps.dpcTriCaps.dwDestBlendCaps & 2) ) + v1 |= 0x20u; + if ( !(halCaps.dpcTriCaps.dwDestBlendCaps & 4) ) + v1 |= 0x40u; + if ( halCaps.dpcTriCaps.dwTextureCaps & 0x20 ) + LOBYTE(v1) = v1 | 0x80; + result = v1; + } + return result; +} + + +//----- (0049E4FC) -------------------------------------------------------- +void RenderD3D::ClearTarget(unsigned int bClearColor, unsigned int uClearColor, unsigned int bClearDepth, float z_clear) +{ + uint uClearFlags = 0; + + if (bClearColor) + uClearFlags |= D3DCLEAR_TARGET; + if (bClearDepth) + uClearFlags |= D3DCLEAR_ZBUFFER; + + D3DRECT rects[] = {{0, 0, 640, 480}}; + if (uClearFlags) + pViewport->Clear2(1, rects, uClearFlags, uClearColor, z_clear, 0); +} + + +//----- (0049E54D) -------------------------------------------------------- +void RenderD3D::Present(bool bForceBlit) +{ + RECT v5; // [sp+18h] [bp-18h]@1 + struct tagPOINT Point; // [sp+28h] [bp-8h]@4 + + v5.left = 0; + v5.top = 0; + v5.bottom = 480; + v5.right = 640; + + if (bWindowed || bForceBlit) + { + RECT rc; + GetClientRect(hWindow, &rc); + Point.y = 0; + Point.x = 0; + ClientToScreen(hWindow, &Point); + OffsetRect(&rc, Point.x, Point.y); + pFrontBuffer->Blt(&rc, pBackBuffer, &v5, DDBLT_WAIT, 0); + } + else + pFrontBuffer->Flip(0, 1); +} + + +//----- (0049E5D4) -------------------------------------------------------- +bool RenderD3D::CreateTexture(unsigned int uTextureWidth, unsigned int uTextureHeight, IDirectDrawSurface4 **pOutSurface, IDirect3DTexture2 **pOutTexture, bool bAlphaChannel, bool bMipmaps, unsigned int uMinDeviceTexDim) +{ + unsigned int v8; // edx@4 + unsigned int v9; // ebx@5 + unsigned int v10; // eax@5 + DWORD v11; // edx@5 + //int v12; // edx@7 + DDSURFACEDESC2 ddsd2; // [sp+Ch] [bp-80h]@1 + //RenderD3D *v15; // [sp+88h] [bp-4h]@1 + + //v15 = this; + memset(&ddsd2, 0, 0x7Cu); + ddsd2.dwSize = 0x7Cu; + ddsd2.dwFlags = DDSD_CAPS | DDSD_WIDTH | DDSD_HEIGHT | DDSD_PIXELFORMAT; + ddsd2.ddsCaps.dwCaps = DDSCAPS_TEXTURE; + ddsd2.ddsCaps.dwCaps2 = DDSCAPS2_TEXTUREMANAGE; + ddsd2.dwHeight = uTextureHeight; + ddsd2.dwWidth = uTextureWidth; + if ( bMipmaps ) + { + if ( (signed int)uTextureHeight <= (signed int)uTextureWidth ) + { + v8 = GetMaxMipLevels(uTextureHeight) - GetMaxMipLevels(uMinDeviceTexDim); +LABEL_8: + ddsd2.dwMipMapCount = v8; + if ( !v8 ) + goto LABEL_12; + goto LABEL_11; + } + if ( (signed int)uTextureWidth < (signed int)uMinDeviceTexDim ) + { + v8 = GetMaxMipLevels(uMinDeviceTexDim); + goto LABEL_8; + } + v9 = GetMaxMipLevels(uTextureWidth); + v10 = GetMaxMipLevels(uMinDeviceTexDim); + ddsd2.dwMipMapCount = v9 - v10; + if ( v9 == v10 ) + { + ddsd2.dwFlags = 0x1007u; + ddsd2.ddsCaps.dwCaps = v11; + goto LABEL_12; + } + } + else + { + ddsd2.dwMipMapCount = 1; + } +LABEL_11: + ddsd2.dwFlags = DDSD_CAPS | DDSD_HEIGHT | DDSD_WIDTH | DDSD_PIXELFORMAT | DDSD_MIPMAPCOUNT; + ddsd2.ddsCaps.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_COMPLEX | DDSCAPS_MIPMAP; +LABEL_12: + ddsd2.ddpfPixelFormat.dwRGBBitCount = 16; + ddsd2.ddpfPixelFormat.dwSize = sizeof(DDPIXELFORMAT); + if (bAlphaChannel) + { + ddsd2.ddpfPixelFormat.dwFlags = DDPF_RGB | DDPF_ALPHAPIXELS; + ddsd2.ddpfPixelFormat.dwRBitMask = 0x7C00; + ddsd2.ddpfPixelFormat.dwGBitMask = 0x03E0; + ddsd2.ddpfPixelFormat.dwBBitMask = 0x001F; + ddsd2.ddpfPixelFormat.dwRGBAlphaBitMask = 0x8000u; + } + else + { + ddsd2.ddpfPixelFormat.dwFlags = DDPF_RGB; + ddsd2.ddpfPixelFormat.dwRBitMask = 0xF800; + ddsd2.ddpfPixelFormat.dwGBitMask = 0x07E0; + ddsd2.ddpfPixelFormat.dwBBitMask = 0x001F; + ddsd2.ddpfPixelFormat.dwRGBAlphaBitMask = 0; + } + if (FAILED(pHost->CreateSurface(&ddsd2, pOutSurface, 0))) + return false; + if (FAILED((*pOutSurface)->QueryInterface(IID_IDirect3DTexture2, (void **)pOutTexture))) + { + (*pOutSurface)->Release(); + *pOutSurface = 0; + return false; + } + return true; +} + +//----- (004A5190) -------------------------------------------------------- +void RenderD3D::HandleLostResources() +{ + pBitmaps_LOD->ReleaseLostHardwareTextures(); + pBitmaps_LOD->_410423_move_textures_to_device(); + pSprites_LOD->ReleaseLostHardwareSprites(); +} + + + +//----- (004A2050) -------------------------------------------------------- +void Render::DrawPolygon(unsigned int uNumVertices, stru148 *a3, ODMFace *a4, IDirect3DTexture2 *pTexture) +{ + Render *v5; // edi@1 + unsigned int v6; // ebx@1 + LightmapBuilder *v7; // esi@3 + int v8; // eax@7 + ODMFace *v9; // eax@12 + char *v10; // esi@12 + double v11; // st7@14 + double v12; // st7@14 + int v13; // eax@14 + ODMFace *v14; // ecx@14 + double v15; // st7@14 + float v16; // ST48_4@15 + int v17; // eax@15 + char v18; // zf@17 + HRESULT v19; // eax@18 + HRESULT v20; // eax@18 + HRESULT v21; // eax@20 + HRESULT v22; // eax@20 + unsigned int v23; // ecx@20 + char *v24; // eax@21 + HRESULT v25; // eax@23 + HRESULT v26; // eax@23 + HRESULT v27; // eax@24 + HRESULT v28; // eax@25 + HRESULT v29; // eax@25 + HRESULT v30; // eax@25 + HRESULT v31; // eax@25 + HRESULT v32; // eax@26 + unsigned int v33; // ecx@26 + char *v34; // eax@27 + int v35; // edx@28 + HRESULT v36; // eax@29 + HRESULT v37; // eax@29 + HRESULT v38; // eax@29 + HRESULT v39; // eax@29 + //IDirect3DDevice3Vtbl *v40; // ebx@29 + unsigned int v41; // eax@29 + HRESULT v42; // eax@30 + HRESULT v43; // eax@30 + HRESULT v44; // eax@30 + char *v45; // esi@34 + int v46; // ecx@35 + double v47; // st6@35 + int v48; // eax@36 + const char *v49; // [sp+4Ch] [bp-1Ch]@0 + const char *v50; // [sp+4Ch] [bp-1Ch]@20 + int v51; // [sp+50h] [bp-18h]@0 + unsigned int v52; // [sp+54h] [bp-14h]@0 + LightmapBuilder *v53; // [sp+58h] [bp-10h]@3 + unsigned int v54; // [sp+5Ch] [bp-Ch]@3 + unsigned int v55; // [sp+5Ch] [bp-Ch]@34 + unsigned int v56; // [sp+60h] [bp-8h]@12 + int v57; // [sp+60h] [bp-8h]@34 + HRESULT a2; // [sp+64h] [bp-4h]@4 + + v5 = this; + v6 = 0; + if ( this->uNumD3DSceneBegins && (signed int)uNumVertices >= 3 ) + { + v7 = pGame->pLightmapBuilder; + v53 = v7; + v54 = v7->std__vector_000004_size; + if ( v7->std__vector_000004_size) + a2 = -1; + pGame->_44EE30(a4, (int)&a2); + if ( byte_4D864C && pGame->uFlags & 1 ) + { + v8 = GetActorTintColor(a3->field_58, 0, array_50AC10[0].vWorldViewPosition.x, 0, 0); + v7->_45D74F_MessWithLight(v8, 0); + } + else + { + if ( !v54 || byte_4D864C && pGame->uFlags & 2 ) + { + ErrD3D(pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_ADDRESS, 1u)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_CULLMODE, D3DCULL_CW)); + if (bUsingSpecular) + { + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ALPHABLENDENABLE, true)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, 2)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, 1)); + } + if ( (signed int)uNumVertices > 0 ) + { + v45 = (char *)&array_50AC10[0].vWorldViewPosition; + v57 = (int)&arary_77E5C8[0].pos.y; + v55 = uNumVertices; + do + { + a2 = GetActorTintColor(a3->field_58, 0, *(float *)v45, 0, 0); + pGame->_44EE30(a4, (int)&a2); + v46 = v57; + v47 = *(float *)v45 * 1000.0 / (double)pOutdoorCamera->shading_dist_mist; + *(int *)(v57 - 4) = *((int *)v45 + 3); + *(int *)v57 = *((int *)v45 + 4); + *(int *)(v57 + 12) = a2; + *(float *)(v57 + 4) = 1.0 - 1.0 / v47; + *(float *)(v57 + 8) = 1.0 / (*(float *)v45 + 0.0000001); + if ( v5->bUsingSpecular ) + { + v48 = sub_47C3D7_get_fog_related_stuff(0, 0, *(float *)v45); + v46 = v57; + } + else + { + v48 = 0; + } + *(int *)(v46 + 16) = v48; + *(int *)(v46 + 20) = *((int *)v45 + 6); + *(int *)(v46 + 24) = *((int *)v45 + 7); + v45 += 48; + v18 = v55-- == 1; + v57 = v46 + 32; + } + while ( !v18 ); + } + pRenderD3D->pDevice->SetTexture(0, pTexture); + pRenderD3D->pDevice->DrawPrimitive(D3DPT_TRIANGLEFAN, + D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_SPECULAR | D3DFVF_TEX1, + arary_77E5C8, + uNumVertices, + D3DDP_DONOTLIGHT); + } + else + { + if ( (signed int)uNumVertices > 0 ) + { + v9 = (ODMFace *)&arary_77E5C8[0].pos.y; + v10 = (char *)&array_50AC10[0].vWorldViewPosition; + a4 = (ODMFace *)&arary_77E5C8[0].pos.y; + v56 = uNumVertices; + while ( 1 ) + { + v11 = *(float *)v10 * 1000.0; + *((int *)v9 - 1) = *((int *)v10 + 3); + v12 = v11 / (double)pOutdoorCamera->shading_dist_mist; + v9->pFacePlane.vNormal.x = *((int *)v10 + 4); + *(float *)&v9->pFacePlane.vNormal.y = 1.0 - 1.0 / v12; + *(float *)&v9->pFacePlane.vNormal.z = 1.0 / (*(float *)v10 + 0.0000001); + v13 = GetActorTintColor(a3->field_58, 0, *(float *)v10, 0, 0); + v14 = a4; + v15 = *(float *)v10; + a4->pFacePlane.dist = v13; + if ( v5->bUsingSpecular ) + { + v16 = v15; + v17 = sub_47C3D7_get_fog_related_stuff(0, 0, v16); + v14 = a4; + } + else + { + v17 = 0; + } + v14->zCalc1 = v17; + v14->zCalc2 = *((int *)v10 + 6); + v14->zCalc3 = *((int *)v10 + 7); + v10 += 48; + v18 = v56-- == 1; + a4 = (ODMFace *)((char *)v14 + 32); + if ( v18 ) + break; + v9 = a4; + } + } + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ZWRITEENABLE, false)); + ErrD3D(pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_ADDRESS, 1u)); + if (bUsingSpecular) + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_FOGENABLE, 0)); + + ErrD3D(pRenderD3D->pDevice->SetTexture(0, nullptr)); + ErrD3D(pRenderD3D->pDevice->DrawPrimitive(D3DPT_TRIANGLEFAN, + D3DFVF_XYZRHW | D3DFVF_TEX1 | D3DFVF_DIFFUSE | D3DFVF_SPECULAR, + arary_77E5C8, + uNumVertices, + D3DDP_DONOTLIGHT)); + //v50 = (const char *)v5->pRenderD3D->pDevice; + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_CULLMODE, D3DCULL_NONE)); + //(*(void (**)(void))(*(int *)v50 + 88))(); + v53->_45D74F_MessWithLight(-1, 0); + v23 = uNumVertices; + if ( (signed int)uNumVertices > 0 ) + { + v24 = (char *)&arary_77E5C8[0].diffuse; + do + { + *(int *)v24 = a2; + v24 += 32; + --v23; + } + while ( v23 ); + } + ErrD3D(pRenderD3D->pDevice->SetTexture(0, pTexture)); + ErrD3D(pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_ADDRESS, 1u)); + if ( !pRenderer->bUsingSpecular ) + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ZWRITEENABLE, true)); + + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ALPHABLENDENABLE, true)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, 1)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, 3)); + ErrD3D(pRenderD3D->pDevice->DrawPrimitive(D3DPT_TRIANGLEFAN, + D3DFVF_XYZRHW | D3DFVF_TEX1 | D3DFVF_DIFFUSE | D3DFVF_SPECULAR, + arary_77E5C8, + uNumVertices, + D3DDP_DONOTLIGHT)); + if (bUsingSpecular) + { + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ZWRITEENABLE, true)); + + v33 = uNumVertices; + if ( (signed int)uNumVertices > 0 ) + { + v34 = (char *)&arary_77E5C8[0].specular; + do + { + v35 = *(int *)v34; + *(int *)v34 = 0; + v34 += 32; + --v33; + *((int *)v34 - 9) = pRenderer->uFogColor | v35 & 0xFF000000; + } + while ( v33 ); + } + ErrD3D(pRenderD3D->pDevice->SetTexture(0, nullptr)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, 6)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, 5)); + ErrD3D(pRenderD3D->pDevice->DrawPrimitive(D3DPT_TRIANGLEFAN, + D3DFVF_XYZRHW | D3DFVF_TEX1 | D3DFVF_DIFFUSE | D3DFVF_SPECULAR, + arary_77E5C8, + uNumVertices, + D3DDP_DONOTLIGHT)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_FOGENABLE, true)); + //v40 = pRenderer->pRenderD3D->pDevice->lpVtbl; + v41 = GetLevelFogColor(); + pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_FOGCOLOR, GetLevelFogColor() & 0xFFFFFF); + v6 = 0; + pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_FOGTABLEMODE, 0); + } + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, 2)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, 1)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ALPHABLENDENABLE, v6)); + } + } + } +} +// 4D864C: using guessed type char byte_4D864C; + + +//----- (0049EB79) -------------------------------------------------------- +Render::~Render() +{ + Render *v1; // esi@1 + + v1 = this; + pAllocator->FreeChunk(this->pDefaultZBuffer); + v1->pD3DBitmaps.Release(); + v1->pD3DSprites.Release(); + Release(); + v1->bWindowMode = 1; + //nullsub_1(); + //nullsub_1(); +} + + + +//----- (0049E756) -------------------------------------------------------- +bool Render::IsColorKeySupported(IDirectDraw4 *this_) +{ + DDCAPS refCaps; // [sp+0h] [bp-2F8h]@1 + DDCAPS halCaps; // [sp+17Ch] [bp-17Ch]@1 + + halCaps.dwSize = 380; + refCaps.dwSize = 380; + this_->GetCaps(&halCaps, &refCaps); + return halCaps.dwSVBCaps & 0x40 && BYTE1(halCaps.dwSVBCKeyCaps) & 2; +} + +//----- (0049E992) -------------------------------------------------------- +Render::Render() +{ + Render *v1; // esi@1 + int v2; // eax@1 + char v3; // zf@1 + + v1 = this; + this->pDirectDraw4 = 0; + this->pFrontBuffer4 = 0; + this->pBackBuffer4 = 0; + this->pColorKeySurface4 = 0; + this->pDirectDraw2 = 0; + this->pFrontBuffer2 = 0; + this->pBackBuffer2 = 0; + this->pSomeSurface2 = 0; + //RenderHWLContainer::RenderHWLContainer(&this->pD3DBitmaps); + //RenderHWLContainer::RenderHWLContainer(&v1->pD3DSprites); + v1->bWindowMode = 1; + v1->field_40054 = 0; + v1->field_10 = 640; + v1->field_14 = 480; + v1->field_40030 = 0; + v1->field_4002C = 0; + v1->pActiveZBuffer = 0; + v1->pDefaultZBuffer = 0; + v1->field_20_clipy = 0; + v1->field_1C_clipx = 0; + v1->field_24_clipz = 639; + v1->field_28_clipw = 479; + v1->field_4003C = (int)&unk_4EED80; + v1->field_40040 = dword_4EED78; + v1->uClipZ = 640; + v1->field_40044 = 2; + v1->field_40048 = 6; + v1->pFrontBuffer4 = 0; + v1->pBackBuffer4 = 0; + v1->pColorKeySurface4 = 0; + v1->pDirectDraw4 = 0; + v1->pRenderD3D = 0; + v1->uNumSceneBegins = 0; + v1->uNumD3DSceneBegins = 0; + v1->field_40110 = 0; + v1->pTargetSurface = 0; + v1->uTargetSurfacePitch = 0; + v1->uClipY = 0; + v1->uClipX = 0; + v1->uClipW = 480; + v1->bClip = 1; + v1->bColorKeySupported = 0; + v1->bRequiredTextureStagesAvailable = 0; + v1->bTinting = 1; + LOBYTE(v1->field_103668) = 0; + v1->field_1036B8 = 0; + v1->_gpu_memory_used = 0; + uNumBillboardsToDraw = 0; + bFogEnabled = false; +} + +bool Render::Initialize(bool bWindowed, uint uDefaultDevice, + bool bColoredLights, uint uDetailLevel, uint bTinting) +{ + bUserDirect3D = true;//ReadWindowsRegistryInt("Use D3D", 0); + bStartInWindow = bWindowed; + + uDesiredDirect3DDevice = uDefaultDevice;//ReadWindowsRegistryInt("D3D Device", 1); + + bUseColoredLights = bColoredLights;//ReadWindowsRegistryInt("Colored Lights", 0); + uLevelOfDetail = uDetailLevel;//ReadWindowsRegistryInt("Detail Level", 1); + + this->bTinting = bTinting; + + auto r1 = pD3DBitmaps.Load(L"data\\d3dbitmap.hwl"); + auto 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) + pRenderD3D->ClearTarget(true, 0, false, 0.0); + } + else + memset(pRenderer->pTargetSurface, 0, 4 * (field_10 * field_14 / 2)); +} + + +//----- (0049ED18) -------------------------------------------------------- +void Render::PresentBlackScreen() +{ + LONG w; // edx@3 + IDirectDrawSurface *v2; // eax@3 + DDBLTFX v3; // [sp+4h] [bp-74h]@5 + RECT x; // [sp+68h] [bp-10h]@3 + + memset(&v3, 0, sizeof(DDBLTFX)); + if (pVersion->pVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT || + pVersion->pVersionInfo.dwMajorVersion >= 5) + { + x.left = uWindowX; + x.right = uWindowX + uWindowHeight; + x.top = uWindowY; + w = uWindowY + uWindowWidth; + v2 = (IDirectDrawSurface *)this->pBackBuffer4; + } + else + { + x.left = uWindowX; + x.right = uWindowX + uWindowHeight; + x.top = uWindowY; + w = uWindowY + uWindowWidth; + v2 = (IDirectDrawSurface *)this->pBackBuffer2; + } + x.bottom = w; + v3.dwFillColor = 0; + v3.dwSize = 100; + v2->Blt(&x, 0, 0, DDBLT_COLORFILL, &v3); + pRenderer->Present(); +} + + +//----- (0049EDB6) -------------------------------------------------------- +void Render::SavePCXScreenshot() +{ + Render *v1; // esi@1 + __int16 v2; // di@1 + int v3; // eax@4 + int v4; // ecx@4 + int v5; // eax@8 + FILE *v6; // edi@10 + int v7; // ecx@11 + int v8; // eax@11 + int v9; // eax@13 + int v10; // ecx@15 + unsigned __int8 v11; // dl@15 + signed int v12; // eax@18 + char v13; // zf@27 + HRESULT v14; // eax@29 + char v15[56]; // [sp+Ch] [bp-158h]@10 + __int16 v16; // [sp+44h] [bp-120h]@10 + DDSURFACEDESC2 Dst; // [sp+48h] [bp-11Ch]@7 + char color_map[48]; // [sp+C4h] [bp-A0h]@10 + char Filename[40]; // [sp+F4h] [bp-70h]@3 + char *v20; // [sp+11Ch] [bp-48h]@14 + char *v21; // [sp+120h] [bp-44h]@14 + int v24; // [sp+124h] [bp-40h]@11 + FILE *File; // [sp+128h] [bp-3Ch]@3 + int var38; // [sp+12Ch] [bp-38h]@4 + PCXHeader_1 header1; // [sp+130h] [bp-34h]@10 + PCXHeader_2 header2; // [sp+140h] [bp-24h]@10 + void *ptr; // [sp+148h] [bp-1Ch]@10 + void *v28; // [sp+14Ch] [bp-18h]@8 + int v29; // [sp+150h] [bp-14h]@4 + int v30; // [sp+154h] [bp-10h]@4 + char v31; // [sp+15Ah] [bp-Ah]@25 + unsigned __int8 v32; // [sp+15Bh] [bp-9h]@17 + 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 ) + { + sprintf(Filename, "screen%0.2i.pcx", dword_4EFA80++ % 100); + File = fopen(Filename, "wb"); + if ( File ) + { + v3 = v1->field_10; + v4 = v1->field_14; + var38 = v3; + v29 = v4; + v30 = v3; + if ( v3 & 1 ) + v30 = v3 + 1; + if ( v1->pRenderD3D ) + { + memset(&Dst, 0, 0x7Cu); + Dst.dwSize = 124; + if ( !pRenderer->LockSurface_DDraw4(pRenderer->pBackBuffer4, &Dst, 1u) ) + return; + v28 = Dst.lpSurface; + v5 = Dst.lPitch >> 1; + v2 = 0; + } + else + { + pRenderer->BeginScene(); + v28 = pRenderer->pTargetSurface; + v5 = pRenderer->uTargetSurfacePitch; + } + i = v5; + header1.right = var38 - 1; + header1.left = v2; + header1.bottom = v29 - 1; + header1.up = v2; + header2.pitch = v30; + memset(color_map, 0, sizeof(color_map)); + memset(v15, 0, sizeof(v15)); + header2.reserved = 0; + header1.manufacturer = 10; + v16 = 0; + v6 = File; + header1.version = 5; + header1.encoding = 1; + header1.bpp = 8; + header1.hdpi = 75; + header1.vdpi = 75; + header2.planes = 3; + header2.palette_info = 1; + fwrite(&header1, 1u, 1u, File); + fwrite(&header1.version, 1u, 1u, v6); + fwrite(&header1.encoding, 1u, 1u, v6); + fwrite(&header1.bpp, 1u, 1u, v6); + fwrite(&header1.left, 2u, 1u, v6); + fwrite(&header1.up, 2u, 1u, v6); + fwrite(&header1.right, 2u, 1u, v6); + fwrite(&header1.bottom, 2u, 1u, v6); + fwrite(&header1.hdpi, 2u, 1u, v6); + fwrite(&header1.vdpi, 2u, 1u, v6); + fwrite(color_map, 0x30u, 1u, v6); + fwrite(&header2, 1u, 1u, v6); + fwrite(&header2.planes, 1u, 1u, v6); + fwrite(&header2.pitch, 2u, 1u, v6); + fwrite(&header2.palette_info, 2u, 1u, v6); + fwrite(v15, 0x3Au, 1u, v6); + ptr = pAllocator->AllocNamedChunk(0, 3 * var38 + 6, 0); + if ( v29 > 0 ) + { + v7 = v30; + File = (FILE *)v29; + v29 = 3 * v30; + v24 = 2 * i; + v8 = (int)v28; + while ( 1 ) + { + i = v8; + v9 = 0; + if ( var38 > 0 ) + { + v21 = (char *)ptr + v7; + v20 = (char *)ptr + 2 * v30; + do + { + *((char *)ptr + v9) = (signed int)(v1->uTargetRMask & *(short *)i) >> (LOBYTE(v1->uTargetGBits) + + LOBYTE(v1->uTargetBBits) + + v1->uTargetRBits + - 8); + v21[v9] = (signed int)(v1->uTargetGMask & *(short *)i) >> (LOBYTE(v1->uTargetBBits) + + LOBYTE(v1->uTargetGBits) + - 8); + v10 = i; + v11 = LOBYTE(v1->uTargetBMask); + i += 2; + v20[v9++] = (*(char *)v10 & v11) << (8 - LOBYTE(v1->uTargetBBits)); + } + while ( v9 < var38 ); + } + for ( i = 0; i < v29; i += v34 ) + { + v34 = 1; + v32 = *((char *)ptr + i); + do + { + v12 = i + v34; + if ( *((char *)ptr + v12) != v32 ) + break; + if ( !(v12 % v30) ) + break; + ++v34; + } + while ( v34 < 0x3Fu ); + if ( i + v34 > v29 ) + v34 = 3 * v30 - i; + if ( v34 > 1u || v32 >= 0xC0u ) + { + v31 = v34 | 0xC0; + fwrite(&v31, 1u, 1u, v6); + } + fwrite(&v32, 1u, 1u, v6); + } + v8 = (int)((char *)v28 + v24); + v13 = File == (FILE *)1; + File = (FILE *)((char *)File - 1); + v28 = (char *)v28 + v24; + if ( v13 ) + break; + v7 = v30; + } + } + if ( v1->pRenderD3D ) + { + ErrD3D(pRenderer->pBackBuffer4->Unlock(0)); + } + else + { + pRenderer->EndScene(); + } + + pAllocator->FreeChunk(ptr); + fclose(v6); + } + } +} +// 4EFA80: using guessed type int dword_4EFA80; + + +//----- (0049F1BC) -------------------------------------------------------- +void Render::_49F1BC(const char *a1) +{ + Render *v2; // esi@1 + __int16 v3; // di@1 + int v4; // eax@4 + char *v5; // ecx@4 + unsigned int v6; // eax@8 + FILE *v7; // edi@10 + int v8; // ecx@11 + int v9; // eax@11 + int v10; // eax@13 + const char *v11; // ecx@15 + unsigned __int8 v12; // dl@15 + signed int v13; // eax@18 + char v14; // zf@27 + HRESULT v15; // eax@29 + char v16; // [sp+Ch] [bp-12Ch]@10 + __int16 v17; // [sp+44h] [bp-F4h]@10 + int Dst; // [sp+48h] [bp-F0h]@7 + int v19; // [sp+58h] [bp-E0h]@8 + unsigned __int16 *v20; // [sp+6Ch] [bp-CCh]@8 + char v21; // [sp+C4h] [bp-74h]@10 + unsigned int v22; // [sp+F4h] [bp-44h]@11 + char *v23; // [sp+F8h] [bp-40h]@14 + int v24; // [sp+FCh] [bp-3Ch]@11 + int v25; // [sp+100h] [bp-38h]@4 + FILE *File; // [sp+104h] [bp-34h]@3 + char Str; // [sp+108h] [bp-30h]@10 + char v28; // [sp+109h] [bp-2Fh]@10 + char v29; // [sp+10Ah] [bp-2Eh]@10 + char v30; // [sp+10Bh] [bp-2Dh]@10 + __int16 v31; // [sp+10Ch] [bp-2Ch]@10 + __int16 v32; // [sp+10Eh] [bp-2Ah]@10 + __int16 v33; // [sp+110h] [bp-28h]@10 + __int16 v34; // [sp+112h] [bp-26h]@10 + __int16 v35; // [sp+114h] [bp-24h]@10 + __int16 v36; // [sp+116h] [bp-22h]@10 + char v37; // [sp+118h] [bp-20h]@10 + char v38; // [sp+119h] [bp-1Fh]@10 + __int16 v39; // [sp+11Ah] [bp-1Eh]@10 + __int16 v40; // [sp+11Ch] [bp-1Ch]@10 + void *ptr; // [sp+120h] [bp-18h]@10 + unsigned __int16 *v42; // [sp+124h] [bp-14h]@8 + int v43; // [sp+128h] [bp-10h]@4 + char v44; // [sp+12Fh] [bp-9h]@25 + 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 ) + { + ++dword_4EFA84; + File = fopen(a1, "wb"); + if ( File ) + { + v4 = v2->field_10; + v5 = (char *)v2->field_14; + v25 = v4; + a1 = v5; + v43 = v4; + if ( v4 & 1 ) + v43 = v4 + 1; + if ( v2->pRenderD3D ) + { + memset(&Dst, 0, 0x7Cu); + Dst = 124; + if ( !pRenderer->LockSurface_DDraw4(pRenderer->pBackBuffer4, (DDSURFACEDESC2 *)&Dst, 1u) ) + return; + v42 = v20; + v6 = v19 >> 1; + v3 = 0; + } + else + { + pRenderer->BeginScene(); + v42 = pRenderer->pTargetSurface; + v6 = pRenderer->uTargetSurfacePitch; + } + i = (char *)v6; + v33 = v25 - 1; + v31 = v3; + v34 = (short)a1 - 1; + v32 = v3; + v39 = v43; + memset(&v21, 0, 0x30u); + memset(&v16, 0, 0x38u); + v37 = 0; + Str = 10; + v17 = 0; + v7 = File; + v28 = 5; + v29 = 1; + v30 = 8; + v35 = 75; + v36 = 75; + v38 = 3; + v40 = 1; + fwrite(&Str, 1u, 1u, File); + fwrite(&v28, 1u, 1u, v7); + fwrite(&v29, 1u, 1u, v7); + fwrite(&v30, 1u, 1u, v7); + fwrite(&v31, 2u, 1u, v7); + fwrite(&v32, 2u, 1u, v7); + fwrite(&v33, 2u, 1u, v7); + fwrite(&v34, 2u, 1u, v7); + fwrite(&v35, 2u, 1u, v7); + fwrite(&v36, 2u, 1u, v7); + fwrite(&v21, 0x30u, 1u, v7); + fwrite(&v37, 1u, 1u, v7); + fwrite(&v38, 1u, 1u, v7); + fwrite(&v39, 2u, 1u, v7); + fwrite(&v40, 2u, 1u, v7); + fwrite(&v16, 0x3Au, 1u, v7); + ptr = pAllocator->AllocNamedChunk(0, 3 * v25 + 6, 0); + if ( (signed int)a1 > 0 ) + { + v8 = v43; + File = (FILE *)a1; + v24 = 3 * v43; + v22 = 2 * (int)i; + v9 = (int)v42; + while ( 1 ) + { + a1 = (const char *)v9; + v10 = 0; + if ( v25 > 0 ) + { + i = (char *)ptr + v8; + v23 = (char *)ptr + 2 * v43; + do + { + *((char *)ptr + v10) = (signed int)(v2->uTargetRMask & *(short *)a1) >> (LOBYTE(v2->uTargetGBits) + + LOBYTE(v2->uTargetBBits) + + v2->uTargetRBits + - 8); + i[v10] = (signed int)(v2->uTargetGMask & *(short *)a1) >> (LOBYTE(v2->uTargetBBits) + + LOBYTE(v2->uTargetGBits) + - 8); + v11 = a1; + v12 = LOBYTE(v2->uTargetBMask); + a1 += 2; + v23[v10++] = ((unsigned __int8)*v11 & v12) << (8 - LOBYTE(v2->uTargetBBits)); + } + while ( v10 < v25 ); + } + for ( i = 0; (signed int)i < v24; i += BYTE3(a1) ) + { + BYTE3(a1) = 1; + v46 = *((char *)ptr + (int)i); + do + { + v13 = (signed int)&i[BYTE3(a1)]; + if ( *((char *)ptr + v13) != v46 ) + break; + if ( !(v13 % v43) ) + break; + ++BYTE3(a1); + } + while ( BYTE3(a1) < 0x3Fu ); + if ( (signed int)&i[BYTE3(a1)] > v24 ) + BYTE3(a1) = 3 * v43 - (char)i; + if ( BYTE3(a1) > 1u || v46 >= 0xC0u ) + { + v44 = BYTE3(a1) | 0xC0; + fwrite(&v44, 1u, 1u, v7); + } + fwrite(&v46, 1u, 1u, v7); + } + v9 = (int)&v42[v22 / 2]; + v14 = File == (FILE *)1; + File = (FILE *)((char *)File - 1); + v42 = (unsigned __int16 *)((char *)v42 + v22); + if ( v14 ) + break; + v8 = v43; + } + } + if ( v2->pRenderD3D ) + { + ErrD3D(pRenderer->pBackBuffer4->Unlock(0)); + } + else + { + pRenderer->EndScene(); + } + pAllocator->FreeChunk(ptr); + fclose(v7); + } + } +} +// 4EFA84: using guessed type int dword_4EFA84; + + + +//----- (0049F5A2) -------------------------------------------------------- +int Render::_49F5A2(int a2, int a3, int a4, void *Dst, int a6, int a7) +{ + Render *v7; // ebx@1 + void *v8; // esi@3 + void *v9; // esi@3 + int v10; // ecx@4 + int v11; // eax@4 + int v12; // eax@6 + int v13; // eax@8 + int v14; // ecx@8 + signed int v15; // eax@11 + char v16; // zf@20 + int result; // eax@21 + char v18[58]; // [sp+Ch] [bp-ACh]@3 + // __int16 v19; // [sp+44h] [bp-74h]@3 + char v20[48]; // [sp+48h] [bp-70h]@3 + char *v21; // [sp+78h] [bp-40h]@7 + char *v22; // [sp+7Ch] [bp-3Ch]@7 + int v23; // [sp+80h] [bp-38h]@4 + int v24; // [sp+84h] [bp-34h]@4 + int v25; // [sp+88h] [bp-30h]@4 + int v26; // [sp+8Ch] [bp-2Ch]@4 + char Src; // [sp+90h] [bp-28h]@3 + char v28; // [sp+91h] [bp-27h]@3 + char v29; // [sp+92h] [bp-26h]@3 + char v30; // [sp+93h] [bp-25h]@3 + __int16 v31; // [sp+94h] [bp-24h]@3 + __int16 v32; // [sp+96h] [bp-22h]@3 + __int16 v33; // [sp+98h] [bp-20h]@3 + __int16 v34; // [sp+9Ah] [bp-1Eh]@3 + __int16 v35; // [sp+9Ch] [bp-1Ch]@3 + __int16 v36; // [sp+9Eh] [bp-1Ah]@3 + char v37; // [sp+A0h] [bp-18h]@3 + char v38; // [sp+A1h] [bp-17h]@3 + __int16 v39; // [sp+A2h] [bp-16h]@3 + __int16 v40; // [sp+A4h] [bp-14h]@3 + void *ptr; // [sp+A8h] [bp-10h]@3 + int v42; // [sp+ACh] [bp-Ch]@1 + char v43; // [sp+B3h] [bp-5h]@18 + int i; // [sp+B4h] [bp-4h]@6 + + v7 = this; + v42 = a3; + if ( a3 & 1 ) + v42 = a3 + 1; + v31 = 0; + v32 = 0; + v33 = a3 - 1; + v34 = a4 - 1; + v39 = v42; + memset(&v20, 0, 0x30u); + memset(&v18, 0, 0x38u); + v8 = Dst; + v37 = 0; + *(_WORD *)&v18[56] = 0; + Src = 10; + v28 = 5; + v29 = 1; + v30 = 8; + v35 = 75; + v36 = 75; + v38 = 3; + v40 = 1; + memcpy(Dst, &Src, 1u); + v8 = (char *)v8 + 1; + memcpy(v8, &v28, 1u); + v8 = (char *)v8 + 1; + memcpy(v8, &v29, 1u); + v8 = (char *)v8 + 1; + memcpy(v8, &v30, 1u); + v8 = (char *)v8 + 1; + memcpy(v8, &v31, 2u); + v8 = (char *)v8 + 2; + memcpy(v8, &v32, 2u); + v8 = (char *)v8 + 2; + memcpy(v8, &v33, 2u); + v8 = (char *)v8 + 2; + memcpy(v8, &v34, 2u); + v8 = (char *)v8 + 2; + memcpy(v8, &v35, 2u); + v8 = (char *)v8 + 2; + memcpy(v8, &v36, 2u); + v8 = (char *)v8 + 2; + memcpy(v8, &v20, 0x30u); + v8 = (char *)v8 + 48; + memcpy(v8, &v37, 1u); + v8 = (char *)v8 + 1; + memcpy(v8, &v38, 1u); + v8 = (char *)v8 + 1; + memcpy(v8, &v39, 2u); + v8 = (char *)v8 + 2; + memcpy(v8, &v40, 2u); + v8 = (char *)v8 + 2; + memcpy(v8, &v18, 0x3Au); + v9 = (char *)v8 + 58; + ptr = pAllocator->AllocNamedChunk(0, 3 * a3 + 6, 0); + if ( a4 > 0 ) + { + v10 = v42; + v25 = a4; + v26 = 3 * v42; + v23 = 2 * a3; + v11 = a2; + v24 = a2; + while ( 1 ) + { + a4 = v11; + v12 = 0; + i = 0; + if ( a3 > 0 ) + { + v21 = (char *)ptr + v10; + v22 = (char *)ptr + 2 * v42; + do + { + *((char *)ptr + v12) = (signed int)(v7->uTargetRMask & *(short *)a4) >> (LOBYTE(v7->uTargetGBits) + + LOBYTE(v7->uTargetBBits) + + v7->uTargetRBits + - 8); + v13 = i; + v21[i] = (signed int)(v7->uTargetGMask & *(short *)a4) >> (LOBYTE(v7->uTargetBBits) + + LOBYTE(v7->uTargetGBits) + - 8); + v14 = a4; + a4 += 2; + v22[v13] = (v7->uTargetBMask & *(char *)v14) << (8 - LOBYTE(v7->uTargetBBits)); + v12 = v13 + 1; + i = v12; + } + while ( v12 < a3 ); + } + for ( i = 0; i < v26; v9 = (char *)v9 + 1 ) + { + BYTE3(a4) = 1; + BYTE3(a2) = *((char *)ptr + i); + do + { + v15 = i + BYTE3(a4); + if ( *((char *)ptr + v15) != BYTE3(a2) ) + break; + if ( !(v15 % v42) ) + break; + ++BYTE3(a4); + } + while ( BYTE3(a4) < 0x3Fu ); + if ( i + BYTE3(a4) > v26 ) + BYTE3(a4) = 3 * v42 - i; + if ( BYTE3(a4) > 1u || BYTE3(a2) >= 0xC0u ) + { + v43 = BYTE3(a4) | 0xC0; + memcpy(v9, &v43, 1u); + v9 = (char *)v9 + 1; + } + memcpy(v9, (char *)&a2 + 3, 1u); + i += BYTE3(a4); + } + v11 = v23 + v24; + v16 = v25-- == 1; + v24 += v23; + if ( v16 ) + break; + v10 = v42; + } + } + pAllocator->FreeChunk(ptr); + result = a7; + *(int *)a7 = (char *)v9 - Dst; + return result; +} + + +//----- (0049F8B5) -------------------------------------------------------- +FILE *Render::SavePCXImage(const char *Filename, char *a3, int a4, int a5) +{ + Render *v5; // esi@1 + FILE *result; // eax@1 + FILE *v7; // edi@4 + int v8; // ecx@5 + int v9; // eax@5 + int v10; // eax@7 + int v11; // ecx@9 + signed int v12; // eax@12 + char v13; // zf@21 + char v14[56]; // [sp+4h] [bp-A0h]@4 + __int16 v15; // [sp+3Ch] [bp-68h]@4 + char color_map[48]; // [sp+40h] [bp-64h]@4 + int v17; // [sp+70h] [bp-34h]@5 + int v18; // [sp+74h] [bp-30h]@5 + char *v19; // [sp+78h] [bp-2Ch]@5 + int v20; // [sp+7Ch] [bp-28h]@5 + PCXHeader_1 header1; // [sp+80h] [bp-24h]@4 + PCXHeader_2 header2; // [sp+90h] [bp-14h]@4 + void *ptr; // [sp+98h] [bp-Ch]@4 + int v24; // [sp+9Ch] [bp-8h]@2 + char *i; // [sp+A0h] [bp-4h]@8 + + v5 = this; + result = fopen(Filename, "wb"); + Filename = (const char *)result; + if ( result ) + { + v24 = a4; + if ( a4 & 1 ) + v24 = a4 + 1; + header1.left = 0; + header1.up = 0; + header1.right = a4 - 1; + header1.bottom = a5 - 1; + header2.pitch = v24; + memset(color_map, 0, sizeof(color_map)); + header2.reserved = 0; + memset(v14, 0, sizeof(v14)); + v15 = 0; + header1.manufacturer = 10; + header1.version = 5; + header1.encoding = 1; + header1.bpp = 8; + header1.hdpi = 75; + header1.vdpi = 75; + header2.planes = 3; + header2.palette_info = 1; + fwrite(&header1, 1u, 1u, (FILE *)Filename); + v7 = (FILE *)Filename; + fwrite(&header1.version, 1u, 1u, (FILE *)Filename); + fwrite(&header1.encoding, 1u, 1u, v7); + fwrite(&header1.bpp, 1u, 1u, v7); + fwrite(&header1.left, 2u, 1u, v7); + fwrite(&header1.up, 2u, 1u, v7); + fwrite(&header1.right, 2u, 1u, v7); + fwrite(&header1.bottom, 2u, 1u, v7); + fwrite(&header1.hdpi, 2u, 1u, v7); + fwrite(&header1.vdpi, 2u, 1u, v7); + fwrite(color_map, 0x30u, 1u, v7); + fwrite(&header2, 1u, 1u, v7); + fwrite(&header2.planes, 1u, 1u, v7); + fwrite(&header2.pitch, 2u, 1u, v7); + fwrite(&header2.palette_info, 2u, 1u, v7); + fwrite(v14, 0x3Au, 1u, v7); + ptr = pAllocator->AllocNamedChunk(0, 3 * a4 + 6, 0); + if ( a5 > 0 ) + { + v8 = v24; + v18 = a5; + v20 = 3 * v24; + v17 = 2 * a4; + v9 = (int)a3; + v19 = a3; + while ( 1 ) + { + a5 = v9; + v10 = 0; + if ( a4 > 0 ) + { + a3 = (char *)ptr + v8; + i = (char *)ptr + 2 * v24; + do + { + *((char *)ptr + v10) = (signed int)(v5->uTargetRMask & *(short *)a5) >> (LOBYTE(v5->uTargetGBits) + + LOBYTE(v5->uTargetBBits) + + v5->uTargetRBits + - 8); + a3[v10] = (signed int)(v5->uTargetGMask & *(short *)a5) >> (LOBYTE(v5->uTargetBBits) + + LOBYTE(v5->uTargetGBits) + - 8); + v11 = a5; + a5 += 2; + i[v10++] = (v5->uTargetBMask & *(char *)v11) << (8 - LOBYTE(v5->uTargetBBits)); + } + while ( v10 < a4 ); + } + for ( i = 0; (signed int)i < v20; i += BYTE3(a5) ) + { + BYTE3(a5) = 1; + BYTE3(Filename) = *((char *)ptr + (int)i); + do + { + v12 = (signed int)&i[BYTE3(a5)]; + if ( *((char *)ptr + v12) != BYTE3(Filename) ) + break; + if ( !(v12 % v24) ) + break; + ++BYTE3(a5); + } + while ( BYTE3(a5) < 0x3Fu ); + if ( (signed int)&i[BYTE3(a5)] > v20 ) + BYTE3(a5) = 3 * v24 - (char)i; + if ( BYTE3(a5) > 1u || BYTE3(Filename) >= 0xC0u ) + { + BYTE3(a3) = BYTE3(a5) | 0xC0; + fwrite((char *)&a3 + 3, 1u, 1u, v7); + } + fwrite((char *)&Filename + 3, 1u, 1u, v7); + } + v9 = (int)&v19[v17]; + v13 = v18-- == 1; + v19 += v17; + if ( v13 ) + break; + v8 = v24; + } + } + pAllocator->FreeChunk(ptr); + result = (FILE *)fclose(v7); + } + return result; +} + + +//----- (0049FBCD) -------------------------------------------------------- +void Render::ClearTarget(unsigned int uColor) +{ + if (pRenderD3D) + { + if (field_40110) + pRenderD3D->ClearTarget(true, uColor, false, 0.0); + } + else + memset32(pTargetSurface, uColor, field_10 * field_14 / 2); +} + + + +//----- (0049FC23) -------------------------------------------------------- +void Render::Release2() +{ + Release(); + bWindowMode = 1; +} + + +//----- (0049FC37) -------------------------------------------------------- +void Render::Present() +{ + Render *v1; // esi@1 + 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 ) + { + this->pBeforePresentFunction(); + if ( v1->pRenderD3D ) + { + if ( v1->field_40110 ) + { + if (pAsyncMouse) + pAsyncMouse->_46BAEC(); + pRenderD3D->Present(false); + if (pAsyncMouse) + pAsyncMouse->_46BB0A(); + } + } + else + { + if ( v1->bWindowMode ) + { + RestoreFrontBuffer(); + GetClientRect(v1->hWnd, &Rect); + Point.y = 0; + Point.x = 0; + ClientToScreen(v1->hWnd, &Point); + OffsetRect(&Rect, Point.x, Point.y); + a4.top = 0; + a4.bottom = 480; + a4.left = 0; + a4.right = 640; + PresentRect(&Rect, &a4); + } + else + { + RestoreFrontBuffer(); + a4.top = 0; + a4.bottom = 480; + a4.left = 0; + a4.right = 640; + BltBackToFontFast(0, 0, &a4); + } + } + } +} + +//----- (0049FD3A) -------------------------------------------------------- +void Render::_49FD3A() +{ + Render *v2; // esi@1 + IDirectDrawSurface4 *v3; // eax@6 + IDirectDrawSurface4 *v4; // ST0C_4@6 + RECT v5; // [sp+8h] [bp-10h]@6 + + auto a1 = this; + v2 = a1; + if ( a1->pRenderD3D ) + { + if (pFrontBuffer4->IsLost() == DDERR_SURFACELOST) + pFrontBuffer4->Restore(); + if (pBackBuffer4->IsLost() == DDERR_SURFACELOST) + pBackBuffer4->Restore(); + v3 = v2->pBackBuffer4; + v4 = v2->pFrontBuffer4; + v5.top = 0; + v5.bottom = 480; + v5.left = 0; + v5.right = 640; + v3->BltFast(0, 0, v4, &v5, 16u); + } +} + + +//----- (0049FDBF) -------------------------------------------------------- +void Render::CreateZBuffer() +{ + if (!pDefaultZBuffer) + { + pDefaultZBuffer = pActiveZBuffer = nullptr; + pDefaultZBuffer = pActiveZBuffer = (int *)pAllocator->AllocNamedChunk(0, 0x12C000, "Z Buf."); + memset32(pActiveZBuffer, 0xFFFF0000u, 0x4B000u); + } +} + + +//----- (0049FE05) -------------------------------------------------------- +void Render::Release() +{ + Render *v1; // esi@1 + RenderD3D *v2; // ecx@1 + char v3; // zf@4 + void *v4; // ebx@6 + IDirectDraw *v5; // eax@10 + IDirectDrawSurface2 *v6; // eax@11 + IDirectDrawSurface2 *v7; // eax@13 + IDirectDrawSurface2 *v8; // eax@15 + IDirectDraw2 *v9; // eax@17 + IDirectDraw4 *v10; // eax@19 + IDirectDrawSurface4 *v11; // eax@20 + IDirectDrawSurface4 *v12; // eax@22 + IDirectDrawSurface4 *v13; // eax@24 + IDirectDraw4 *v14; // eax@26 + unsigned __int16 **v15; // ebx@28 + void **v16; // esi@29 + + v1 = this; + v2 = this->pRenderD3D; + if ( v2 ) + { + if ( v1->field_40110 ) + { + pRenderD3D->ClearTarget(1u, 0, 0, 1.0); + pRenderD3D->Present(0); + pRenderD3D->ClearTarget(1u, 0, 0, 1.0); + } + v1->pColorKeySurface4 = 0; + v1->pBackBuffer4 = 0; + v3 = v1->pTargetSurface == 0; + v1->pFrontBuffer4 = 0; + v1->pDirectDraw4 = 0; + if ( !v3 ) + { + free(v1->ptr_400E8); + v1->pTargetSurface = 0; + v1->ptr_400E8 = 0; + } + v4 = v1->pRenderD3D; + if ( v4 ) + { + pRenderD3D->Release(); + free(v4); + } + v1->pRenderD3D = 0; + } + else + { + if ( bWinNT4_0 == 1 ) + { + v5 = (IDirectDraw *)v1->pDirectDraw2; + if ( !v5 ) + return; + v5->SetCooperativeLevel(v1->hWnd, 8u); + v1->pDirectDraw2->FlipToGDISurface(); + v6 = v1->pSomeSurface2; + if ( v6 ) + { + v6->Release(); + v1->pSomeSurface2 = 0; + } + v7 = v1->pBackBuffer2; + if ( v7 ) + { + v7->Release(); + v1->pBackBuffer2 = 0; + } + v8 = v1->pFrontBuffer2; + if ( v8 ) + { + v8->Release(); + v1->pFrontBuffer2 = 0; + } + v9 = v1->pDirectDraw2; + if ( v9 ) + { + v9->Release(); + v1->pDirectDraw2 = 0; + } + } + else + { + v10 = v1->pDirectDraw4; + if ( !v10 ) + return; + v10->SetCooperativeLevel(v1->hWnd, 1032u); + v1->pDirectDraw4->FlipToGDISurface(); + v11 = v1->pColorKeySurface4; + if ( v11 ) + { + v11->Release(); + v1->pColorKeySurface4 = 0; + } + v12 = v1->pBackBuffer4; + if ( v12 ) + { + v12->Release(); + v1->pBackBuffer4 = 0; + } + v13 = v1->pFrontBuffer4; + if ( v13 ) + { + v13->Release(); + v1->pFrontBuffer4 = 0; + } + v14 = v1->pDirectDraw4; + if ( v14 ) + { + v14->Release(); + v1->pDirectDraw4 = 0; + } + } + v15 = &v1->pTargetSurface; + if ( v1->pTargetSurface ) + { + v16 = (void **)&v1->ptr_400E8; + free(*v16); + *v15 = 0; + *v16 = 0; + } + } +} + +//----- (0049FFD7) -------------------------------------------------------- +void Render::CreateSomeTexture() +{ + pRenderD3D->CreateTexture(64, 64, &pSurface, &pTexture, true, false, 32); +} + +//----- (0049FFFB) -------------------------------------------------------- +bool Render::InitializeFullscreen(HWND hWnd) +{ + //Render *v2; // esi@1 + //HWND v3; // ebx@1 + //void *v4; // eax@2 + //RenderD3D *v5; // eax@3 + unsigned int v6; // edx@5 + RenderD3D__DevInfo *v7; // ecx@5 + bool v8; // eax@6 + RenderD3D *v9; // ecx@13 + unsigned int v10; // eax@13 + 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 + char v17; // zf@35 + IDirectDraw4 *v18; // eax@38 + HRESULT v19; // eax@38 + 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 + + //v2 = this; + this->field_40110 = 0; + this->pColorKeySurface4 = 0; + this->pBackBuffer4 = 0; + this->pFrontBuffer4 = 0; + this->pDirectDraw4 = 0; + this->bColorKeySupported = 0; + Release(); + //v3 = hWnd; + this->hWnd = hWnd; + CreateZBuffer(); + if ( bUserDirect3D ) + { + pRenderD3D = new RenderD3D; + v28 = pRenderD3D; + v6 = uDesiredDirect3DDevice; + v29 = -1; + v7 = pRenderD3D->pAvailableDevices; + if ( v7[v6].bIsDeviceCompatible ) + { + v8 = pRenderD3D->CreateDevice(v6, 0, hWnd); + uAcquiredDirect3DDevice = uDesiredDirect3DDevice; + } + else + { + if ( v7[1].bIsDeviceCompatible ) + { + v8 = pRenderD3D->CreateDevice(1u, 0, hWnd); + uAcquiredDirect3DDevice = 1; + } + else + { + if ( !v7->bIsDeviceCompatible ) + Abortf("There aren't any D3D devices to create."); + v8 = pRenderD3D->CreateDevice(0, 0, hWnd); + uAcquiredDirect3DDevice = 0; + } + } + if ( !v8 ) + Abortf("D3Drend->Init failed."); + v9 = pRenderD3D; + pBackBuffer4 = v9->pBackBuffer; + pFrontBuffer4 = v9->pFrontBuffer; + pDirectDraw4 = v9->pHost; + v10 = pRenderD3D->GetDeviceCaps(); + if ( v10 & 1 ) + { + if ( pRenderD3D ) + { + pRenderD3D->Release(); + delete pRenderD3D; + } + pRenderD3D = 0; + pBackBuffer4 = 0; + pFrontBuffer4 = 0; + pDirectDraw4 = 0; + Abortf("Direct3D renderer: The device failed to return capabilities."); + } + if ( v10 & 0x3E ) + { + if ( pRenderD3D ) + { + pRenderD3D->Release(); + delete pRenderD3D; + } + pColorKeySurface4 = 0; + pRenderD3D = 0; + pBackBuffer4 = 0; + pFrontBuffer4 = 0; + pDirectDraw4 = 0; + Abortf("Direct3D renderer: The device doesn't support the necessary alpha blending modes."); + } + if ( (v10 & 0x80u) != 0 ) + { + if ( pRenderD3D ) + { + pRenderD3D->Release(); + delete pRenderD3D; + } + pRenderD3D = 0; + pBackBuffer4 = 0; + pFrontBuffer4 = 0; + pDirectDraw4 = 0; + Abortf("Direct3D renderer: The device doesn't support non-square textures."); + } + LOBYTE(field_10365C) = ~(unsigned __int8)(v10 >> 6) & 1; + bRequiredTextureStagesAvailable = CheckTextureStages(); + memset(&halCaps, 0, 0xFCu); + halCaps.dwSize = 252; + memset(&refCaps, 0, 0xFCu); + v11 = pRenderD3D; + refCaps.dwSize = 252; + ErrD3D(v11->pDevice->GetCaps(&halCaps, &refCaps)); + v13 = halCaps.dwMinTextureWidth; + if ( (unsigned int)halCaps.dwMinTextureWidth >= halCaps.dwMinTextureHeight ) + v13 = halCaps.dwMinTextureHeight; + v14 = halCaps.dwMaxTextureWidth; + uMinDeviceTextureDim = v13; + if ( (unsigned int)v14 < halCaps.dwMaxTextureHeight ) + v14 = halCaps.dwMaxTextureHeight; + uMaxDeviceTextureDim = v14; + if ( (unsigned int)v13 < 4 ) + uMinDeviceTextureDim = 4; + CreateSomeTexture(); + v15 = 1; + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ZENABLE, true)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ZWRITEENABLE, true)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ZFUNC, 2u)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_SPECULARENABLE, false)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_COLORKEYENABLE, false)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ALPHATESTENABLE, false)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_CULLMODE, 1u)); + ErrD3D(pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_MAGFILTER, 2u)); + ErrD3D(pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_MINFILTER, 2u)); + ErrD3D(pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_MIPFILTER, 3u)); + ErrD3D(pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, 2u)); + ErrD3D(pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_ALPHAARG2, 0)); + 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)); + } + else + { + CreateDirectDraw(); + SetDirectDrawCooperationMode(hWnd, 1); + SetDirectDrawDisplayMode(640u, 480u, 16u); + CreateDirectDrawPrimarySurface(); + v15 = 1; + } + ddpfPrimareSuface.dwSize = 32; + GetTargetPixelFormat(&ddpfPrimareSuface); + ParseTargetPixelFormat(); + _49EBF1(); + if ( pRenderD3D ) + { + v16 = IsColorKeySupported(pDirectDraw4); + v17 = uAcquiredDirect3DDevice == v15; + bColorKeySupported = v16; + if ( !v17 ) + bColorKeySupported = 0; + if ( bColorKeySupported ) + { + memset(&ddsd2, 0, 0x7Cu); + ddsd2.ddckCKSrcBlt.dwColorSpaceLowValue = uTargetGMask | uTargetBMask; + ddsd2.ddckCKSrcBlt.dwColorSpaceHighValue = ddsd2.ddckCKSrcBlt.dwColorSpaceLowValue; + v18 = pDirectDraw4; + ddsd2.dwSize = 124; + ddsd2.dwFlags = 65543; + ddsd2.ddsCaps.dwCaps = 2112; + ddsd2.dwWidth = 640; + ddsd2.dwHeight = 480; + ErrD3D(v18->CreateSurface(&ddsd2, &pColorKeySurface4, 0)); + pBeforePresentFunction = Present_ColorKey; + } + else + { + pTargetSurface = 0; + ptr_400E8 = 0; + v20 = (int *)operator new(0x96020u); + ptr_400E8 = v20; + 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; + 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); + } + field_40110 = v15; + } + else + { + pBeforePresentFunction = 0;//nullsub_1; + } + bWindowMode = 0; + pParty->uFlags |= 2u; + LODWORD(flt_6BE3A0) = 0x3F0CCCCDu; + pViewport->_4C02F8(36044); + return v15; +} +// 6BE3A0: using guessed type float flt_6BE3A0; + + +//----- (004A05F3) -------------------------------------------------------- +bool Render::SwitchToWindow(HWND hWnd) +{ + //Render *v2; // esi@1 + //void *v3; // eax@2 + //RenderD3D *v4; // eax@3 + //unsigned int v5; // edx@5 + //RenderD3D__DevInfo *v6; // ecx@5 + bool v7; // eax@7 + //RenderD3D *v8; // ecx@12 + 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 + char v15; // zf@32 + IDirectDraw4 *v16; // eax@35 + HRESULT v17; // eax@35 + 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 + DDSURFACEDESC2 pDesc; // [sp+108h] [bp-204h]@37 + 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; + //v2 = this; + flt_6BE3A0 = 0.55000001f; + pViewport->_4C02F8(36044); + field_40110 = 0; + Release(); + pColorKeySurface4 = 0; + pBackBuffer4 = 0; + pFrontBuffer4 = 0; + pDirectDraw4 = 0; + bColorKeySupported = 0; + CreateZBuffer(); + if ( bUserDirect3D ) + { + /*v3 = operator new(0x148u); + thisa = (RenderD3D *)v3; + v29 = 0; + if ( v3 ) + v4 = RenderD3D::RenderD3D((RenderD3D *)v3); + else + v4 = 0;*/ + pRenderD3D = new RenderD3D; + //v4 = pRenderD3D; + //v5 = uDesiredDirect3DDevice; + v29 = -1; + //v6 = pRenderD3D->pAvailableDevices; + if (pRenderD3D->pAvailableDevices[uDesiredDirect3DDevice].bIsDeviceCompatible && + uDesiredDirect3DDevice != 1 ) + { + v7 = pRenderD3D->CreateDevice(uDesiredDirect3DDevice, 1, hWnd); + uAcquiredDirect3DDevice = uDesiredDirect3DDevice; + } + else + { + if ( !pRenderD3D->pAvailableDevices[0].bIsDeviceCompatible ) + Abortf("There aren't any D3D devices to init."); + v7 = pRenderD3D->CreateDevice(0, 1, hWnd); + uAcquiredDirect3DDevice = 0; + } + if ( !v7 ) + Abortf("D3Drend->Init failed."); + + //v8 = pRenderD3D; + pColorKeySurface4 = 0; + pBackBuffer4 = pRenderD3D->pBackBuffer; + pFrontBuffer4 = pRenderD3D->pFrontBuffer; + pDirectDraw4 = pRenderD3D->pHost; + v9 = pRenderD3D->GetDeviceCaps(); + if ( v9 & 1 ) + { + if (pRenderD3D) + { + pRenderD3D->Release(); + delete pRenderD3D; + } + pRenderD3D = 0; + pBackBuffer4 = 0; + pFrontBuffer4 = 0; + pDirectDraw4 = 0; + Abortf("Direct3D renderer: The device failed to return capabilities."); + } + if ( v9 & 0x3E ) + { + if (pRenderD3D) + { + pRenderD3D->Release(); + delete pRenderD3D; + } + pColorKeySurface4 = 0; + pRenderD3D = 0; + pBackBuffer4 = 0; + pFrontBuffer4 = 0; + pDirectDraw4 = 0; + Abortf("Direct3D renderer: The device doesn't support the necessary alpha blending modes."); + } + if ( (v9 & 0x80u) != 0 ) + { + if (pRenderD3D) + { + pRenderD3D->Release(); + delete pRenderD3D; + } + pRenderD3D = 0; + pBackBuffer4 = 0; + pFrontBuffer4 = 0; + pDirectDraw4 = 0; + Abortf("Direct3D renderer: The device doesn't support non-square textures."); + } + LOBYTE(field_10365C) = ~(unsigned __int8)(v9 >> 6) & 1; + bRequiredTextureStagesAvailable = CheckTextureStages(); + memset(&halCaps, 0, 0xFCu); + halCaps.dwSize = 252; + 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 ) + v12 = halCaps.dwMinTextureHeight; + uMinDeviceTextureDim = v12; + v13 = halCaps.dwMaxTextureWidth; + if ( (unsigned int)halCaps.dwMaxTextureWidth < halCaps.dwMaxTextureHeight ) + v13 = halCaps.dwMaxTextureHeight; + uMaxDeviceTextureDim = v13; + CreateSomeTexture(); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ZENABLE, 1u)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ZWRITEENABLE, 1u)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ZFUNC, 2u)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_SPECULARENABLE, 0)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_COLORKEYENABLE, 0)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_CULLMODE, 1u)); + ErrD3D(pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_MAGFILTER, 2u)); + ErrD3D(pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_MINFILTER, 2u)); + ErrD3D(pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_MIPFILTER, 3u)); + ErrD3D(pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, 2u)); + ErrD3D(pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_ALPHAARG2, 0)); + 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)); + } + else + { + CreateDirectDraw(); + SetDirectDrawCooperationMode(hWnd, 0); + field_4004C = 1; + CreateFrontBuffer(); + CreateClipper(hWnd); + CreateBackBuffer(); + field_40030 = 0; + field_18_locked_pitch = 0; + } + ddpfPrimareSuface.dwSize = 32; + GetTargetPixelFormat(&ddpfPrimareSuface); + ParseTargetPixelFormat(); + _49EBF1(); + if ( !pRenderD3D ) + { + pBeforePresentFunction = 0;//nullsub_1; + goto LABEL_47; + } + v14 = IsColorKeySupported(pDirectDraw4); + v15 = uAcquiredDirect3DDevice == 1; + bColorKeySupported = v14; + if ( !v15 ) + bColorKeySupported = 0; + if ( bColorKeySupported ) + { + 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; +LABEL_45: + field_40110 = 1; +LABEL_47: + bWindowMode = 1; + hWnd = hWnd; + return 0; + } + pTargetSurface = 0; + ptr_400E8 = 0; + v18 = (int *)new char[0x96020]; + memset(v18, -1, 0x96020); + ptr_400E8 = v18; + if ( v18 ) + { + memset(&pDesc, 0, 0x7Cu); + pDesc.dwSize = 124; + if ( pRenderer->LockSurface_DDraw4(pRenderer->pBackBuffer4, &pDesc, 1u) ) + { + pRenderer->pBackBuffer4->Unlock(0); + v19 = ptr_400E8; + v20 = (unsigned int)pDesc.lpSurface & 7; + v21 = (unsigned int)ptr_400E8 & 7; + if ( v21 == v20 ) + { + pTargetSurface = (unsigned __int16 *)v19; + } + else + { + 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; + pBeforePresentFunction = Present_NoColorKey; + goto LABEL_45; + } + } + return 0; +} + + +//----- (004A0BEE) -------------------------------------------------------- +char Render::Line2D(unsigned int uX, unsigned int uY, unsigned int uZ, unsigned int uW, unsigned __int16 uColor) +{ + int v6; // edi@1 + int v7; // edx@5 + unsigned int v8; // ebx@5 + int v9; // eax@7 + unsigned int v10; // ecx@9 + unsigned int v11; // esi@13 + int v12; // eax@17 + int v13; // eax@21 + Render *v14; // edi@21 + int v15; // eax@25 + int v16; // eax@27 + signed int v17; // eax@28 + signed int v18; // edi@30 + signed __int64 v19; // qax@41 + int v20; // edi@41 + unsigned int v21; // edi@46 + int v22; // esi@47 + int v23; // ebx@47 + signed int v24; // edx@50 + signed int v25; // esi@52 + unsigned __int16 *v26; // ecx@52 + int v27; // ebx@54 + int v28; // edi@55 + int v29; // edx@55 + int v30; // ebx@60 + int v31; // edx@61 + int v32; // edi@61 + int v34; // [sp+Ch] [bp-10h]@3 + Render *v35; // [sp+10h] [bp-Ch]@1 + __int64 v36; // [sp+14h] [bp-8h]@1 + signed int v37; // [sp+18h] [bp-4h]@28 + unsigned int uXa; // [sp+24h] [bp+8h]@49 + unsigned int uYa; // [sp+28h] [bp+Ch]@28 + int uYb; // [sp+28h] [bp+Ch]@47 + int uZa; // [sp+2Ch] [bp+10h]@38 + + v36 = 0i64; + v6 = this->field_1C_clipx; + v35 = this; + if ( (signed int)uX < v6 ) + HIDWORD(v36) = 8; + v34 = this->field_24_clipz; + if ( (signed int)uX > this->field_24_clipz ) + HIDWORD(v36) |= 4u; + v7 = this->field_20_clipy; + v8 = uY; + if ( (signed int)uY < v7 ) + HIDWORD(v36) |= 2u; + v9 = this->field_28_clipw; + if ( (signed int)uY > v9 ) + HIDWORD(v36) |= 1u; + v10 = uZ; + if ( (signed int)uZ < v6 ) + LODWORD(v36) = 8; + if ( (signed int)uZ > v34 ) + LODWORD(v36) = v36 | 4; + v11 = uW; + if ( (signed int)uW < v7 ) + LODWORD(v36) = v36 | 2; + if ( (signed int)uW > v9 ) + LODWORD(v36) = v36 | 1; + LOBYTE(v12) = v36; + if ( (unsigned int)v36 & HIDWORD(v36) ) + return v12; + if ( !v36 ) + { +LABEL_46: + v21 = pRenderer->uTargetSurfacePitch; + if ( pRenderer->uTargetSurfacePitch ) + { + v12 = uX + v8 * pRenderer->uTargetSurfacePitch; + v22 = v11 - v8; + v23 = v22; + uYb = v22; + if ( v22 < 0 ) + { + v23 = -v22; + uYb = -v22; + v21 = -pRenderer->uTargetSurfacePitch; + } + uXa = v10 - uX; + if ( (uXa & 0x80000000u) == 0 ) + { + v24 = 1; + } + else + { + uXa = -uXa; + v24 = -1; + } + v25 = 0; + v26 = v35->pTargetSurface; + if ( v26 ) + { + if ( (signed int)uXa <= v23 ) + { + v30 = v23 + 1; + if ( v30 > 0 ) + { + v31 = 2 * v24; + v32 = 2 * v21; + v12 = (int)&v26[v12]; + do + { + v25 += uXa; + *(short *)v12 = uColor; + v12 += v32; + if ( v25 > 0 ) + { + v25 -= uYb; + v12 += v31; + } + --v30; + } + while ( v30 ); + } + } + else + { + v27 = uXa + 1; + if ( (signed int)(uXa + 1) > 0 ) + { + v28 = 2 * v21; + v29 = 2 * v24; + v12 = (int)&v26[v12]; + do + { + v25 += uYb; + *(short *)v12 = uColor; + v12 += v29; + if ( v25 > (signed int)uXa ) + { + v25 -= uXa; + v12 += v28; + } + --v27; + } + while ( v27 ); + } + } + } + } + return v12; + } + if ( (BYTE4(v36) ^ (unsigned __int8)v36) & 8 ) + { + if ( BYTE4(v36) & 8 ) + { + v13 = (signed int)((uW - uY) * (v6 - uX)) / (signed int)(uZ - uX); + v14 = v35; + v8 = v13 + uY; + uX = v35->field_1C_clipx; + goto LABEL_24; + } + v10 = v6; + v11 = (signed int)((uY - uW) * (v6 - uZ)) / (signed int)(uX - uZ) + uW; + } + v14 = v35; +LABEL_24: + if ( (BYTE4(v36) ^ (unsigned __int8)v36) & 4 ) + { + v15 = v14->field_24_clipz; + if ( BYTE4(v36) & 4 ) + { + v14 = v35; + v8 += (signed int)((v11 - v8) * (v15 - uX)) / (signed int)(v10 - uX); + uX = v35->field_24_clipz; + } + else + { + v16 = (signed int)((v8 - v11) * (v15 - v10)) / (signed int)(uX - v10); + v10 = v14->field_24_clipz; + v11 += v16; + } + } + v17 = v14->field_20_clipy; + v37 = 0; + uYa = v14->field_20_clipy; + if ( (signed int)v8 < v17 ) + v37 = 2; + v18 = v14->field_28_clipw; + if ( (signed int)v8 > v18 ) + v37 |= 1u; + if ( (signed int)v11 >= v17 ) + v12 = 0; + else + v12 = 2; + if ( (signed int)v11 > v18 ) + LOBYTE(v12) = v12 | 1; + if ( !(v12 & v37) ) + { + v12 ^= v37; + uZa = v12; + if ( v12 & 2 ) + { + if ( v37 & 2 ) + { + uX += (signed int)((v10 - uX) * (uYa - v8)) / (signed int)(v11 - v8); + LOBYTE(v12) = (char)v35; + v8 = v35->field_20_clipy; + } + else + { + v19 = (signed int)((uX - v10) * (uYa - v11)); + v20 = v8 - v11; + v11 = uYa; + v12 = v19 / v20; + v10 += v12; + } + } + if ( uZa & 1 ) + { + if ( v37 & 1 ) + { + uX += (signed int)((v10 - uX) * (v35->field_28_clipw - v8)) / (signed int)(v11 - v8); + LOBYTE(v12) = (char)v35; + v8 = v35->field_28_clipw; + } + else + { + v12 = (signed int)((uX - v10) * (v35->field_28_clipw - v11)) / (signed int)(v8 - v11); + v11 = v35->field_28_clipw; + v10 += v12; + } + } + goto LABEL_46; + } + return v12; +} + + + +//----- (004A0E80) -------------------------------------------------------- +void Render::ClearZBuffer(int a2, int a3) +{ + memset32(this->pActiveZBuffer, -65536, 0x4B000u); +} + + + +//----- (004A0E97) -------------------------------------------------------- +void Render::Clip_v2(unsigned int uX, unsigned int uY, unsigned int uZ, unsigned int uW) +{ + this->field_1C_clipx = uX; + this->field_20_clipy = uY; + this->field_24_clipz = uZ; + this->field_28_clipw = uW; +} + + +//----- (004A0EB6) -------------------------------------------------------- +void Render::ParseTargetPixelFormat() +{ + Render *v1; // eax@1 + signed int v2; // ecx@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 + + v1 = this; + v2 = 0; + uRedMask = v1->ddpfPrimareSuface.dwRBitMask; + v1->uTargetBBits = 0; + v1->uTargetGBits = 0; + v1->uTargetRBits = 0; + do + { + if ( (1 << v2) & uRedMask ) + ++v1->uTargetRBits; + ++v2; + } + while ( v2 < 16 ); + uGreenMask = v1->ddpfPrimareSuface.dwGBitMask; + v5 = 0; + do + { + if ( (1 << v5) & uGreenMask ) + ++v1->uTargetGBits; + ++v5; + } + while ( v5 < 16 ); + uBlueMask = v1->ddpfPrimareSuface.dwBBitMask; + v7 = 0; + do + { + if ( (1 << v7) & uBlueMask ) + ++v1->uTargetBBits; + ++v7; + } + while ( v7 < 16 ); + v8 = v1->ddpfPrimareSuface.dwRBitMask; + v1->uTargetGMask = uGreenMask; + v1->uTargetRMask = v8; + v1->uTargetBMask = uBlueMask; +} + +//----- (004A0F40) -------------------------------------------------------- +bool Render::LockSurface_DDraw4(IDirectDrawSurface4 *pSurface, DDSURFACEDESC2 *pDesc, unsigned int uLockFlags) +{ + IDirectDrawSurface4 *v4; // esi@1 + bool result; // eax@1 + HRESULT v6; // eax@4 + int v7; // [sp-8h] [bp-14h]@10 + unsigned int v8; // [sp-4h] [bp-10h]@10 + char v9; // [sp+Bh] [bp-1h]@1 + + v4 = pSurface; + v9 = 1; + result = pSurface->Lock(0, pDesc, uLockFlags, 0); + if ( result == DDERR_SURFACELOST ) + { + if (pAsyncMouse) + pAsyncMouse->Suspend(); + v6 = v4->Restore(); + if ( v6 ) + { + if ( v6 != DDERR_IMPLICITLYCREATED ) + { +LABEL_20: + v9 = 0; + result = (bool)memset(pDesc, 0, 4u); + goto LABEL_21; + } + pRenderer->pFrontBuffer4->Restore(); + v4->Restore(); + } + result = v4->Lock(0, pDesc, DDLOCK_WAIT, 0); + if ( result == DDERR_INVALIDRECT || result == DDERR_SURFACEBUSY ) + goto LABEL_20; + ErrD3D(result); + if ( result ) + { + //v8 = 0; + //v7 = 2161; +LABEL_19: + //CheckHRESULT((CheckHRESULT_stru0 *)&pSurface, result, "E:\\WORK\\MSDEV\\MM7\\MM7\\Code\\Screen16.cpp", v7, v8); + goto LABEL_20; + } + if ( pRenderer->pRenderD3D ) + pRenderD3D->HandleLostResources(); + result = pRenderer->pDirectDraw4->RestoreAllSurfaces(); + if (pAsyncMouse) + pAsyncMouse->Resume(); + } + else + { + if ( result ) + { + if ( result == DDERR_INVALIDRECT || result == DDERR_SURFACEBUSY ) + goto LABEL_20; + ErrD3D(result); + //v8 = 0; + //v7 = 2199; + //goto LABEL_19; + } + } +LABEL_21: + LOBYTE(result) = v9; + return result; +} + + +//----- (004A1032) -------------------------------------------------------- +bool Render::LockSurface_DDraw2(IDirectDrawSurface2 *pSurface, DDSURFACEDESC *pDesc, unsigned int uLockFlags) +{ + IDirectDrawSurface2 *v4; // esi@1 + bool v5; // eax@1 + HRESULT v6; // eax@2 + int v7; // [sp-8h] [bp-10h]@8 + unsigned int v8; // [sp-4h] [bp-Ch]@8 + + v4 = pSurface; + v5 = pSurface->Lock( + 0, + pDesc, + uLockFlags, + 0); + BYTE3(pSurface) = 1; + if ( v5 == DDERR_SURFACELOST ) + { + v6 = v4->Restore(); + if ( !v6 ) + goto LABEL_5; + if ( v6 == DDERR_IMPLICITLYCREATED ) + { + pRenderer->pFrontBuffer2->Restore(); + v4->Restore(); +LABEL_5: + v5 = v4->Lock(0, pDesc, 1u, 0) != 0; + if ( v5 == DDERR_INVALIDRECT || v5 == DDERR_SURFACEBUSY ) + goto LABEL_14; + if ( !v5 ) + return true; + ErrD3D(v5); + //v8 = 0; + //v7 = 2247; + goto LABEL_13; + } + else + { + pDesc->dwSize = 0; + return false; + } + } + else + { + if ( !v5 ) + return true; + if ( v5 != DDERR_INVALIDRECT && v5 != DDERR_SURFACEBUSY ) + { + //v8 = 0; + //v7 = 2269; + ErrD3D(v5); + pDesc->dwSize = 0; + return false; +LABEL_13: + //CheckHRESULT((CheckHRESULT_stru0 *)&pSurface, v5, "E:\\WORK\\MSDEV\\MM7\\MM7\\Code\\Screen16.cpp", v7, v8); + goto LABEL_14; + } + } +LABEL_14: + return true; +} + +//----- (004A10E4) -------------------------------------------------------- +void Render::CreateDirectDraw() +{ + Render *v1; // edi@1 + HRESULT v2; // eax@1 + HRESULT v3; // eax@5 + int v6; // [sp-Ch] [bp-20h]@3 + unsigned int v9; // [sp+0h] [bp-14h]@0 + IDirectDraw *lpDD; // [sp+10h] [bp-4h]@1 + + v1 = this; + ErrD3D(DirectDrawCreate(0, &lpDD, 0)); + + pDirectDraw2 = nullptr; + pDirectDraw4 = nullptr; + + if ( pVersion->pVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT || pVersion->pVersionInfo.dwMajorVersion != 4 ) + ErrD3D(lpDD->QueryInterface(IID_IDirectDraw4, (void **)&pDirectDraw4)); + else + ErrD3D(lpDD->QueryInterface(IID_IDirectDraw2, (void **)&pDirectDraw2)); + + lpDD->Release(); + lpDD = nullptr; +} + +//----- (004A1169) -------------------------------------------------------- +void Render::SetDirectDrawCooperationMode(HWND hWnd, bool bFullscreen) +{ + DWORD flags; // eax@1 + IDirectDraw *v4; // ecx@3 + HRESULT v5; // eax@5 + int v6; // [sp-8h] [bp-8h]@3 + unsigned int v7; // [sp-4h] [bp-4h]@3 + + flags = bFullscreen ? DDSCL_NORMAL | DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN : + DDSCL_NORMAL; + + if ( pVersion->pVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT || pVersion->pVersionInfo.dwMajorVersion != 4 ) + ErrD3D(pDirectDraw4->SetCooperativeLevel(hWnd, flags | DDSCL_MULTITHREADED)); + else + ErrD3D(pDirectDraw2->SetCooperativeLevel(hWnd, flags)); +} + +//----- (004A11C6) -------------------------------------------------------- +void Render::SetDirectDrawDisplayMode(unsigned int uWidth, unsigned int uHeight, unsigned int uBPP) +{ + if ( pVersion->pVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT || pVersion->pVersionInfo.dwMajorVersion != 4 ) + ErrD3D(pDirectDraw4->SetDisplayMode(uWidth, uHeight, uBPP, 0, 0)); + else + ErrD3D(pDirectDraw2->SetDisplayMode(uWidth, uHeight, uBPP, 0, 0)); +} + +//----- (004A121C) -------------------------------------------------------- +void Render::CreateFrontBuffer() +{ + Render *v1; // esi@1 + IDirectDraw *pDD; // eax@3 + IDirectDrawSurface **pOutSurf; // esi@3 + struct _DDSURFACEDESC *v4; // edx@3 + HRESULT v5; // eax@5 + int v6; // [sp-8h] [bp-8Ch]@3 + unsigned int v7; // [sp-4h] [bp-88h]@3 + DDSURFACEDESC2 a2; // [sp+4h] [bp-80h]@3 + + v1 = this; + if ( pVersion->pVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT || pVersion->pVersionInfo.dwMajorVersion != 4 ) + { + memset(&a2, 0, 0x7Cu); + pDD = (IDirectDraw *)v1->pDirectDraw4; + a2.dwSize = 124; + a2.dwFlags = 1; + v7 = 0; + a2.ddsCaps.dwCaps = 512; + v6 = 2357; + pOutSurf = (IDirectDrawSurface **)&v1->pFrontBuffer4; + v4 = (struct _DDSURFACEDESC *)&a2; + } + else + { + memset(&a2.lPitch, 0, 0x6Cu); // DDSURFACEDESC here + pDD = (IDirectDraw *)v1->pDirectDraw2; + a2.lPitch = 108; + a2.dwBackBufferCount = 1; + v7 = 0; + a2.dwTextureStage = 512; + v6 = 2346; + pOutSurf = (IDirectDrawSurface **)&v1->pFrontBuffer2; + v4 = (struct _DDSURFACEDESC *)&a2.lPitch; + } + ErrD3D(pDD->CreateSurface(v4, pOutSurf, 0)); +} + +//----- (004A12CD) -------------------------------------------------------- +void Render::CreateBackBuffer() +{ + Render *v1; // esi@1 + IDirectDraw *v2; // eax@3 + IDirectDrawSurface **ppBackBuffer; // esi@3 + struct _DDSURFACEDESC *v4; // edx@3 + HRESULT v5; // eax@5 + int v6; // [sp-8h] [bp-8Ch]@3 + unsigned int v7; // [sp-4h] [bp-88h]@3 + DDSURFACEDESC2 a2; // [sp+4h] [bp-80h]@3 + + v1 = this; + if ( pVersion->pVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT || pVersion->pVersionInfo.dwMajorVersion != 4 ) + { + memset(&a2, 0, 0x7Cu); + v2 = (IDirectDraw *)v1->pDirectDraw4; + a2.dwSize = 124; + a2.dwFlags = 7; + v7 = 0; + a2.ddsCaps.dwCaps = 2112; + a2.dwWidth = 640; + a2.dwHeight = 480; + v6 = 2387; + ppBackBuffer = (IDirectDrawSurface **)&v1->pBackBuffer4; + v4 = (struct _DDSURFACEDESC *)&a2; + } + else + { + memset(&a2.lPitch, 0, 0x6Cu); + v2 = (IDirectDraw *)v1->pDirectDraw2; + a2.lPitch = 108; + a2.dwBackBufferCount = 7; + v7 = 0; + a2.dwTextureStage = 2112; + a2.dwAlphaBitDepth = 640; + a2.dwMipMapCount = 480; + v6 = 2374; + ppBackBuffer = (IDirectDrawSurface **)&v1->pBackBuffer2; + v4 = (struct _DDSURFACEDESC *)&a2.lPitch; // //DDSURFACEDESC here fo ddraw2 + } + ErrD3D(v2->CreateSurface(v4, ppBackBuffer, 0)); +} + +//----- (004A139A) -------------------------------------------------------- +void Render::CreateDirectDrawPrimarySurface() +{ + Render *v1; // esi@1 + int v2; // ebx@3 + IDirectDraw2 *v3; // eax@3 + HRESULT v4; // eax@3 + IDirectDrawSurface *pFrontBuffer; // eax@3 + DDSCAPS2 *v6; // edx@3 + IDirectDraw4 *v7; // eax@4 + HRESULT v8; // eax@4 + int v9; // ST14_4@5 + IDirectDrawSurface *v10; // ST10_4@5 + HRESULT v11; // eax@5 + IDirectDrawSurface **ppBackBuffer; // [sp-4h] [bp-A4h]@3 + const char *v13; // [sp+0h] [bp-A0h]@0 + int v14; // [sp+4h] [bp-9Ch]@0 + unsigned int v15; // [sp+8h] [bp-98h]@0 + DDSURFACEDESC2 ddsd2; // [sp+Ch] [bp-94h]@3 + DDSCAPS2 v17; // [sp+88h] [bp-18h]@4 + int a4; // [sp+98h] [bp-8h]@3 + + v1 = this; + if ( pVersion->pVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT || pVersion->pVersionInfo.dwMajorVersion != 4 ) + { + v2 = 0; + this->field_4004C = 1; + memset(&ddsd2, 0, 0x7Cu); + v7 = v1->pDirectDraw4; + ddsd2.dwBackBufferCount = 1; + ddsd2.dwSize = 0x7Cu; + ddsd2.dwFlags = DDSD_CAPS | DDSD_BACKBUFFERCOUNT; + ddsd2.ddsCaps.dwCaps = DDSCAPS_COMPLEX | DDSCAPS_FLIP | DDSCAPS_3DDEVICE | DDSCAPS_PRIMARYSURFACE; + ErrD3D(v7->CreateSurface( + &ddsd2, + &pFrontBuffer4, + 0)); + pFrontBuffer = (IDirectDrawSurface *)v1->pFrontBuffer4; + ppBackBuffer = (IDirectDrawSurface **)&v1->pBackBuffer4; + } + else + { + v2 = 0; + this->field_4004C = 1; + + DDSURFACEDESC ddsd; + memset(&ddsd, 0, sizeof(DDSURFACEDESC)); + + ddsd.lpSurface = (LPVOID)1; + ddsd.lPitch = 108; + ddsd.dwBackBufferCount = 33; + ddsd.ddsCaps.dwCaps = 8728; + ErrD3D(pDirectDraw2->CreateSurface( + &ddsd, + (IDirectDrawSurface **)&pFrontBuffer2, + 0)); + + pFrontBuffer = (IDirectDrawSurface *)v1->pFrontBuffer2; + ppBackBuffer = (IDirectDrawSurface **)&v1->pBackBuffer2; + } + v9 = (int)v6; + v10 = pFrontBuffer; // BUG + + v17.dwCaps = 4; + ErrD3D(pFrontBuffer->GetAttachedSurface((DDSCAPS *)&v17, ppBackBuffer));// hr = this->pFrontBuffer->GetAttachedSurface(&ddsCaps2, ppBackBuffer); + //CheckHRESULT(&thisa, v11, (const char *)v10, v9, (unsigned int)ppBackBuffer); + v1->field_40030 = v2; + v1->field_18_locked_pitch = v2; +} + +//----- (004A14F4) -------------------------------------------------------- +void Render::CreateClipper(HWND a2) +{ + if ( pVersion->pVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT || pVersion->pVersionInfo.dwMajorVersion != 4 ) + { + ErrD3D(pDirectDraw4->CreateClipper(0, &pDDrawClipper, 0)); + ErrD3D(pDDrawClipper->SetHWnd(0, a2)); + ErrD3D(pFrontBuffer4->SetClipper(pDDrawClipper)); + } + else + { + ErrD3D(pDirectDraw2->CreateClipper(0, &pDDrawClipper, 0)); + ErrD3D(pDDrawClipper->SetHWnd(0, a2)); + } +} + +//----- (004A15D8) -------------------------------------------------------- +void Render::GetTargetPixelFormat(DDPIXELFORMAT *pOut) +{ + IDirectDrawSurface *v2; // eax@3 + + if ( pVersion->pVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT || pVersion->pVersionInfo.dwMajorVersion != 4 ) + v2 = (IDirectDrawSurface *)this->pFrontBuffer4; + else + v2 = (IDirectDrawSurface *)this->pFrontBuffer2; + v2->GetPixelFormat(pOut); +} + +//----- (004A1605) -------------------------------------------------------- +void Render::LockRenderSurface(void **pOutSurfacePtr, unsigned int *pOutPixelsPerRow) +{ + Render *v3; // esi@1 + signed int v4; // eax@3 + + v3 = this; + if ( pVersion->pVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT || pVersion->pVersionInfo.dwMajorVersion != 4 ) + { + DDSURFACEDESC2 pDesc; // [sp+4h] [bp-7Ch]@3 + memset(&pDesc, 0, 0x7Cu); + pDesc.dwSize = 124; + LockSurface_DDraw4(v3->pBackBuffer4, &pDesc, 1u); + *pOutSurfacePtr = pDesc.lpSurface; + v4 = pDesc.lPitch; + } + else + { + DDSURFACEDESC pDesc; // [sp+4h] [bp-7Ch]@3 + memset(&pDesc.lPitch, 0, 0x6Cu); + pDesc.lPitch = 108; + LockSurface_DDraw2(v3->pBackBuffer2, &pDesc, 1u); + *pOutSurfacePtr = (void *)pDesc.lpSurface; + v4 = pDesc.dwReserved; + } + *pOutPixelsPerRow = v4 >> 1; +} + +//----- (004A169E) -------------------------------------------------------- +bool Render::UsingDirect3D() +{ + return bUserDirect3D == 0; +} + + +//----- (004A16E1) -------------------------------------------------------- +void Render::UnlockBackBuffer() +{ + if ( pVersion->pVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT || pVersion->pVersionInfo.dwMajorVersion != 4 ) + ErrD3D(pBackBuffer4->Unlock(0)); + else + ErrD3D(pBackBuffer2->Unlock(0)); +} + + +//----- (004A172E) -------------------------------------------------------- +void Render::LockFrontBuffer(void **pOutSurface, unsigned int *pOutPixelsPerRow) +{ + Render *v3; // esi@1 + signed int v4; // eax@3 + + v3 = this; + if ( pVersion->pVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT || pVersion->pVersionInfo.dwMajorVersion != 4 ) + { + DDSURFACEDESC2 pDesc; // [sp+4h] [bp-7Ch]@3 + memset(&pDesc, 0, 0x7Cu); + pDesc.dwSize = 124; + LockSurface_DDraw4(v3->pFrontBuffer4, &pDesc, 1u); + *pOutSurface = pDesc.lpSurface; + v4 = pDesc.lPitch; + } + else + { + DDSURFACEDESC pDesc; // [sp+4h] [bp-7Ch]@3 + memset(&pDesc.lPitch, 0, 0x6Cu); + pDesc.lPitch = 108; + LockSurface_DDraw2(v3->pFrontBuffer2, &pDesc, 1u); + *pOutSurface = (void *)pDesc.lpSurface; + v4 = pDesc.dwReserved; + } + *pOutPixelsPerRow = v4 >> 1; +} + +//----- (004A17C7) -------------------------------------------------------- +void Render::UnlockFrontBuffer() +{ + IDirectDrawSurface *pFront; // eax@3 + HRESULT v2; // eax@5 + signed int v3; // [sp-8h] [bp-Ch]@3 + int v4; // [sp-4h] [bp-8h]@3 + + auto a5 = this; + if ( pVersion->pVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT || pVersion->pVersionInfo.dwMajorVersion != 4 ) + { + pFront = (IDirectDrawSurface *)a5->pFrontBuffer4; + v4 = 0; + v3 = 2615; + } + else + { + pFront = (IDirectDrawSurface *)a5->pFrontBuffer2; + v4 = 0; + v3 = 2611; + } + ErrD3D(pFront->Unlock(0)); +} + + +//----- (004A1814) -------------------------------------------------------- +void Render::RestoreFrontBuffer() +{ + IDirectDrawSurface **v1; // esi@2 + + if ( pVersion->pVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT + || (v1 = (IDirectDrawSurface **)&this->pFrontBuffer2, pVersion->pVersionInfo.dwMajorVersion >= 5u) ) + v1 = (IDirectDrawSurface **)&this->pFrontBuffer4; + if ( (*v1)->IsLost() == DDERR_SURFACELOST ) + (*v1)->Restore(); +} + + +//----- (004A184C) -------------------------------------------------------- +HRESULT Render::_4A184C() +{ + IDirectDrawSurface **pBack; // esi@2 + HRESULT result; // eax@4 + + if ( pVersion->pVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT + || (pBack = (IDirectDrawSurface **)&this->pBackBuffer2, pVersion->pVersionInfo.dwMajorVersion != 4) ) + pBack = (IDirectDrawSurface **)&this->pBackBuffer4; + result = (*pBack)->IsLost(); + if ( result == DDERR_SURFACELOST ) + result = (*pBack)->Restore(); + return result; +} + +//----- (004A1884) -------------------------------------------------------- +void Render::PresentRect(RECT *a2, RECT *a3) +{ + IDirectDrawSurface *pFront; // eax@3 + HRESULT v4; // eax@5 + IDirectDrawSurface *pBack; // [sp-1Ch] [bp-1Ch]@3 + struct tagRECT *v6; // [sp-18h] [bp-18h]@3 + DWORD v7; // [sp-14h] [bp-14h]@3 + DDBLTFX *v8; // [sp-10h] [bp-10h]@3 + const char *v9; // [sp-Ch] [bp-Ch]@3 + int v10; // [sp-8h] [bp-8h]@3 + unsigned int v11; // [sp-4h] [bp-4h]@3 + + if ( pVersion->pVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT || pVersion->pVersionInfo.dwMajorVersion != 4 ) + { + v11 = 0; + pFront = (IDirectDrawSurface *)this->pFrontBuffer4; + v10 = 2657; + v9 = "E:\\WORK\\MSDEV\\MM7\\MM7\\Code\\Screen16.cpp"; + v8 = 0; + v7 = DDBLT_WAIT; + v6 = a3; + pBack = (IDirectDrawSurface *)this->pBackBuffer4; + } + else + { + v11 = 0; + pFront = (IDirectDrawSurface *)this->pFrontBuffer2; + v10 = 2653; + v9 = "E:\\WORK\\MSDEV\\MM7\\MM7\\Code\\Screen16.cpp"; + v8 = 0; + v7 = DDBLT_WAIT; + v6 = a3; + pBack = (IDirectDrawSurface *)this->pBackBuffer2; + } + ErrD3D(pFront->Blt(a2, pBack, v6, v7, v8)); +} + + +//----- (004A18F5) -------------------------------------------------------- +void Render::BltToFront(RECT *pDstRect, IDirectDrawSurface *pSrcSurface, RECT *pSrcRect, unsigned int uBltFlags) +{ + IDirectDrawSurface *pFront; // eax@3 + HRESULT v6; // eax@5 + int v7; // [sp-8h] [bp-8h]@3 + unsigned int v8; // [sp-4h] [bp-4h]@3 + + if ( pVersion->pVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT || pVersion->pVersionInfo.dwMajorVersion >= 5u ) + ErrD3D(pFrontBuffer4->Blt(pDstRect, (IDirectDrawSurface4 *)pSrcSurface, pSrcRect, uBltFlags, nullptr)); + else + ErrD3D(pFrontBuffer2->Blt(pDstRect, (IDirectDrawSurface2 *)pSrcSurface, pSrcRect, uBltFlags, nullptr)); +} + +//----- (004A194A) -------------------------------------------------------- +void Render::BltBackToFontFast(int a2, int a3, RECT *a4) +{ + IDirectDrawSurface *pFront; // eax@3 + IDirectDrawSurface *pBack; // [sp-Ch] [bp-Ch]@3 + RECT *v6; // [sp-8h] [bp-8h]@3 + DWORD v7; // [sp-4h] [bp-4h]@3 + + if ( pVersion->pVersionInfo.dwPlatformId != VER_PLATFORM_WIN32_NT || pVersion->pVersionInfo.dwMajorVersion != 4 ) + { + pFront = (IDirectDrawSurface *)this->pFrontBuffer4; + v7 = DDBLTFAST_WAIT; + v6 = a4; + pBack = (IDirectDrawSurface *)this->pBackBuffer4; + } + else + { + pFront = (IDirectDrawSurface *)this->pFrontBuffer2; + v7 = DDBLTFAST_WAIT; + v6 = a4; + pBack = (IDirectDrawSurface *)this->pBackBuffer2; + } + pFront->BltFast(0, 0, pBack, v6, v7); +} + +//----- (004A1B22) -------------------------------------------------------- +unsigned int Render::Billboard_ProbablyAddToListAndSortByZOrder(unsigned int a1) +{ + unsigned int v2; // ebx@1 + double v4; // st7@5 + unsigned int v5; // esi@5 + int v6; // ecx@5 + unsigned int v7; // edx@6 + char *v8; // ecx@12 + void *v9; // edi@16 + unsigned int v10; // eax@16 + void *v11; // edi@21 + unsigned int v12; // eax@21 + + v2 = pRenderer->uNumBillboardsToDraw; + if ( (signed int)pRenderer->uNumBillboardsToDraw >= 999 ) + return 0; + if ( !pRenderer->uNumBillboardsToDraw ) + { + pRenderer->uNumBillboardsToDraw = 1; + return 0; + } + v4 = *(float *)&a1; + v5 = pRenderer->uNumBillboardsToDraw; + v6 = 0; + if ( (signed int)pRenderer->uNumBillboardsToDraw <= 0 ) + { + v7 = a1; + } + else + { + do + { + v7 = v6 + (signed int)(v5 - v6) / 2; + if ( v4 <= pRenderer->pBillboardRenderListD3D[v6 + (signed int)(v5 - v6) / 2].flt_88 ) + v5 = v6 + (signed int)(v5 - v6) / 2; + else + v6 = v7 + 1; + } + while ( v6 < (signed int)v5 ); + } + v8 = (char *)&pRenderer->pBillboardRenderListD3D[v7].flt_88; + if ( v4 > *(float *)v8 ) + { + if ( v7 == pRenderer->uNumBillboardsToDraw - 1 ) + { + v7 = pRenderer->uNumBillboardsToDraw; + } + else + { + if ( (signed int)pRenderer->uNumBillboardsToDraw > (signed int)v7 ) + { + v9 = &pRenderer->pBillboardRenderListD3D[pRenderer->uNumBillboardsToDraw]; + v10 = pRenderer->uNumBillboardsToDraw - v7; + do + { + memcpy(v9, (char *)v9 - 156, 0x9Cu); + v9 = (char *)v9 - 156; + --v10; + } + while ( v10 ); + } + ++v7; + } +LABEL_23: + pRenderer->uNumBillboardsToDraw = v2 + 1; + return v7; + } + if ( v4 <= *(float *)v8 ) + { + if ( (signed int)pRenderer->uNumBillboardsToDraw > (signed int)v7 ) + { + v11 = &pRenderer->pBillboardRenderListD3D[pRenderer->uNumBillboardsToDraw]; + v12 = pRenderer->uNumBillboardsToDraw - v7; + do + { + memcpy(v11, (char *)v11 - 156, 0x9Cu); + v11 = (char *)v11 - 156; + --v12; + } + while ( v12 ); + } + goto LABEL_23; + } + return v7; +} + + +//----- (004A1E9D) -------------------------------------------------------- +unsigned int Render::GetBillboardDrawListSize() +{ + return pRenderer->uNumBillboardsToDraw; +} + +//----- (004A1EA3) -------------------------------------------------------- +unsigned int Render::GetParentBillboardID(unsigned int uBillboardID) +{ + return pRenderer->pBillboardRenderListD3D[uBillboardID].uParentBillboardID; +} + +//----- (004A1EB6) -------------------------------------------------------- +void Render::BeginSceneD3D() +{ + if (!uNumD3DSceneBegins++) + { + if (pRenderD3D) + { + pRenderD3D->ClearTarget(true, 0x00F08020, true, 1.0); + pRenderer->uNumBillboardsToDraw = 0; + pRenderD3D->pDevice->BeginScene(); + if (!pRenderD3D->DoesRaiseExceptions()) + { + MessageBoxW(nullptr, L"Error executing scratch 3D operations", L"E:\\WORK\\MSDEV\\MM7\\MM7\\Code\\screen16_3d.cpp:360", 0); + } + if ( uCurrentlyLoadedLevelType == LEVEL_Outdoor ) + uFogColor = GetLevelFogColor(); + else + uFogColor = 0; + + if ( uFogColor & 0xFF000000 ) + { + pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_FOGENABLE, 1); + pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_FOGCOLOR, uFogColor & 0xFFFFFF); + pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_FOGTABLEMODE, 0); + bUsingSpecular = true; + } + else + { + pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_FOGENABLE, 0); + bUsingSpecular = 0; + } + } + else + { + LockRenderSurface((void **)&pTargetSurface, &uTargetSurfacePitch); + if (pTargetSurface) + field_18_locked_pitch = uTargetSurfacePitch; + else + --uNumD3DSceneBegins; + } + } +} + +//----- (004A1FE1) -------------------------------------------------------- +void Render::DrawBillboards_And_MaybeRenderSpecialEffects_And_EndScene() +{ + --uNumD3DSceneBegins; + if (uNumD3DSceneBegins) + return; + + if (pRenderD3D) + { + pGame->draw_debug_outlines(); + //DoRenderBillboards_D3D(); Ritor1: it's temporarily + pGame->pStru6Instance->RenderSpecialEffects(); + pRenderD3D->pDevice->EndScene(); + } + else + pGame->pStru6Instance->RenderSpecialEffects(); +} + + + +//----- (004A2031) -------------------------------------------------------- +unsigned int Render::GetActorTintColor(float a2, int a3, int a4, int a5, RenderBillboard *a6) +{ + return ::GetActorTintColor(a3, a4, a2, a5, a6); +} + + +//----- (004A26BC) -------------------------------------------------------- +void Render::DrawTerrainPolygon(unsigned int uNumVertices, stru148 *a4, IDirect3DTexture2 *a5, int a6, int a7) +{ + RenderVertexSoft *pVertices; // esi@0 + Render *v7; // edi@1 + unsigned int v8; // ebx@1 + LightmapBuilder *v9; // esi@3 + unsigned int v10; // edx@3 + int v11; // eax@5 + int v12; // eax@11 + char *v13; // esi@11 + double v14; // st7@13 + double v15; // st7@13 + signed int v16; // eax@13 + int v17; // ecx@13 + double v18; // st7@13 + float v19; // ST78_4@14 + int v20; // eax@14 + char v21; // zf@16 + HRESULT v22; // eax@17 + HRESULT v23; // eax@17 + HRESULT v24; // eax@19 + HRESULT v25; // eax@19 + unsigned int v26; // ecx@19 + char *v27; // eax@20 + HRESULT v28; // eax@22 + HRESULT v29; // eax@22 + HRESULT v30; // eax@23 + HRESULT v31; // eax@24 + HRESULT v32; // eax@24 + HRESULT v33; // eax@24 + HRESULT v34; // eax@24 + HRESULT v35; // eax@25 + HRESULT v36; // eax@25 + unsigned int v37; // ecx@25 + char *v38; // eax@26 + int v39; // edx@27 + HRESULT v40; // eax@28 + HRESULT v41; // eax@28 + HRESULT v42; // eax@28 + HRESULT v43; // eax@28 + //IDirect3DDevice3Vtbl *v44; // ebx@28 + unsigned int v45; // eax@28 + HRESULT v46; // eax@29 + HRESULT v47; // eax@29 + HRESULT v48; // eax@29 + IDirect3DDevice3 *v49; // eax@35 + //IDirect3DDevice3Vtbl *v50; // ecx@35 + int v51; // eax@40 + char *v52; // esi@40 + double v53; // st7@42 + double v54; // st7@42 + signed int v55; // eax@42 + int v56; // ecx@42 + double v57; // st7@42 + float v58; // ST7C_4@43 + int v59; // eax@43 + signed int v60; // [sp+78h] [bp-14h]@31 + RenderVertexSoft *v61; // [sp+7Ch] [bp-10h]@3 + const char *v62; // [sp+80h] [bp-Ch]@0 + const char *v63; // [sp+80h] [bp-Ch]@19 + int v64; // [sp+84h] [bp-8h]@0 + LightmapBuilder *v65; // [sp+88h] [bp-4h]@3 + unsigned int v66; // [sp+88h] [bp-4h]@40 + unsigned int a6a; // [sp+A0h] [bp+14h]@11 + + v7 = this; + v8 = 0; + if ( this->uNumD3DSceneBegins && (signed int)uNumVertices >= 3 ) + { + v61 = pVertices; + v9 = pGame->pLightmapBuilder; + v65 = v9; + v10 = v9->std__vector_000004_size; + if ( byte_4D864C && pGame->uFlags & 1 ) + { + v11 = GetActorTintColor(a4->field_58, 0, array_50AC10[0].vWorldViewPosition.x, 0, 0); + v9->_45D74F_MessWithLight(v11, 0); + } + else + { + if ( a6 || !v10 || byte_4D864C && pGame->uFlags & 2 ) + { + if ( (char)a7 ) + v60 = 3; + else + v60 = 1; + ErrD3D(pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_ADDRESS, v60)); + if ( a6 || v7->bUsingSpecular ) + { + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ALPHABLENDENABLE, 1u)); + //v49 = v7->pRenderD3D->pDevice; + //v50 = v49->lpVtbl; + if ( a6 ) + { + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, 5)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, 6)); + } + else + { + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, 2)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, 1)); + } + + } + if ( (signed int)uNumVertices > 0 ) + { + v51 = (int)&arary_77E5C8[0].pos.y; + v52 = (char *)&array_50AC10[0].vWorldViewPosition; + a7 = (int)&arary_77E5C8[0].pos.y; + v66 = uNumVertices; + while ( 1 ) + { + v53 = *(float *)v52 * 1000.0; + *(int *)(v51 - 4) = *((int *)v52 + 3); + v54 = v53 / (double)pOutdoorCamera->shading_dist_mist; + *(int *)v51 = *((int *)v52 + 4); + *(float *)(v51 + 4) = 1.0 - 1.0 / v54; + *(float *)(v51 + 8) = 1.0 / (*(float *)v52 + 0.0000001); + v55 = GetActorTintColor(a4->field_58, 0, *(float *)v52, 0, 0); + v56 = a7; + v57 = *(float *)v52; + *(int *)(a7 + 12) = v55; + if ( v7->bUsingSpecular ) + { + v58 = v57; + v59 = sub_47C3D7_get_fog_related_stuff(0, 0, v58); + v56 = a7; + } + else + { + v59 = 0; + } + *(int *)(v56 + 16) = v59; + *(int *)(v56 + 20) = *((int *)v52 + 6); + *(int *)(v56 + 24) = *((int *)v52 + 7); + v52 += 48; + v21 = v66-- == 1; + a7 = v56 + 32; + if ( v21 ) + break; + v51 = a7; + } + } + ErrD3D(pRenderD3D->pDevice->SetTexture(0, a5)); + ErrD3D(pRenderD3D->pDevice->DrawPrimitive( + D3DPT_TRIANGLEFAN, + D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_SPECULAR | D3DFVF_TEX1, + arary_77E5C8, + uNumVertices, + 16)); + if ( a6 ) + { + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ALPHABLENDENABLE, 0)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, 2u)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, 1u)); + } + } + else + { + if ( (signed int)uNumVertices > 0 ) + { + v12 = (int)&arary_77E5C8[0].pos.y; + v13 = (char *)&array_50AC10[0].vWorldViewPosition; + a7 = (int)&arary_77E5C8[0].pos.y; + a6a = uNumVertices; + while ( 1 ) + { + v14 = *(float *)v13 * 1000.0; + *(int *)(v12 - 4) = *((int *)v13 + 3); + v15 = v14 / (double)pOutdoorCamera->shading_dist_mist; + *(int *)v12 = *((int *)v13 + 4); + *(float *)(v12 + 4) = 1.0 - 1.0 / v15; + *(float *)(v12 + 8) = 1.0 / (*(float *)v13 + 0.0000001); + v16 = GetActorTintColor(a4->field_58, 0, *(float *)v13, 0, 0); + v17 = a7; + v18 = *(float *)v13; + *(int *)(a7 + 12) = v16; + if ( v7->bUsingSpecular ) + { + v19 = v18; + v20 = sub_47C3D7_get_fog_related_stuff(0, 0, v19); + v17 = a7; + } + else + { + v20 = 0; + } + *(int *)(v17 + 16) = v20; + *(int *)(v17 + 20) = *((int *)v13 + 6); + *(int *)(v17 + 24) = *((int *)v13 + 7); + v13 += 48; + v21 = a6a-- == 1; + a7 = v17 + 32; + if ( v21 ) + break; + v12 = a7; + } + } + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ZWRITEENABLE, false)); + ErrD3D(pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_ADDRESS, 1u)); + if ( pRenderer->bUsingSpecular ) + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_FOGENABLE, 0)); + + ErrD3D(pRenderD3D->pDevice->SetTexture(0, 0)); + ErrD3D(pRenderD3D->pDevice->DrawPrimitive( + D3DPT_TRIANGLEFAN, + D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_SPECULAR | D3DFVF_TEX1, + arary_77E5C8, + uNumVertices, + 16)); + //v63 = (const char *)v7->pRenderD3D->pDevice; + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_CULLMODE, 1)); + //(*(void (**)(void))(*(int *)v63 + 88))(); + pGame->pLightmapBuilder->_45D74F_MessWithLight(-1, 0); + v26 = uNumVertices; + if ( (signed int)uNumVertices > 0 ) + { + v27 = (char *)&arary_77E5C8[0].diffuse; + do + { + *(int *)v27 = -1; + v27 += 32; + --v26; + } + while ( v26 ); + } + ErrD3D(pRenderD3D->pDevice->SetTexture(0, a5)); + ErrD3D(pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_ADDRESS, 1u)); + if ( !pRenderer->bUsingSpecular ) + { + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ZWRITEENABLE, 1u)); + } + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ALPHABLENDENABLE, 1u)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, 1u)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, 3u)); + ErrD3D(pRenderD3D->pDevice->DrawPrimitive( + D3DPT_TRIANGLEFAN, + D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_SPECULAR | D3DFVF_TEX1, + arary_77E5C8, + uNumVertices, + 16)); + if ( pRenderer->bUsingSpecular ) + { + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ZWRITEENABLE, 1u)); + ErrD3D(pRenderD3D->pDevice->SetTexture(0, 0)); + v37 = uNumVertices; + if ( (signed int)uNumVertices > 0 ) + { + v38 = (char *)&arary_77E5C8[0].specular; + do + { + v39 = *(int *)v38; + *(int *)v38 = 0; + v38 += 32; + --v37; + *((int *)v38 - 9) = pRenderer->uFogColor | v39 & 0xFF000000; + } + while ( v37 ); + } + ErrD3D(pRenderD3D->pDevice->SetTexture(0, 0)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, 6u)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, 5u)); + ErrD3D(pRenderD3D->pDevice->DrawPrimitive( + D3DPT_TRIANGLEFAN, + D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_SPECULAR | D3DFVF_TEX1, + arary_77E5C8, + uNumVertices, + 16)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_FOGENABLE, 1)); + //v44 = pRenderer->pRenderD3D->pDevice; + v45 = GetLevelFogColor(); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_FOGCOLOR, v45 & 0xFFFFFF)); + v8 = 0; + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_FOGTABLEMODE, 0)); + } + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, 2)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, 1u)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ALPHABLENDENABLE, v8)); + } + } + if ( pIndoorCamera->field_4C & 2 || pBLVRenderParams->uFlags & 2 ) + pGame->pIndoorCameraD3D->debug_outline_d3d(arary_77E5C8, uNumVertices, 0xFFFFFFu, 0.0); + } +} +// 4A26BC: could not find valid save-restore pair for esi +// 4D864C: using guessed type char byte_4D864C; + + +//----- (004A2DA3) -------------------------------------------------------- +void Render::DrawFan(unsigned int uNumVertices, stru148 *a3, IDirect3DTexture2 *a4) +{ + Render *v4; // ebx@1 + char *v5; // esi@6 + char *v6; // edi@6 + double v7; // st7@7 + float v8; // ST34_4@7 + int v9; // eax@7 + signed int v10; // eax@7 + double v11; // st7@7 + int v12; // eax@7 + float v13; // ST3C_4@8 + unsigned int v14; // [sp+4Ch] [bp-4h]@6 + + v4 = this; + if ( this->uNumD3DSceneBegins && (signed int)uNumVertices >= 3 ) + { + ErrD3D(pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_ADDRESS, 1u)); + if ( v4->bUsingSpecular ) + { + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ALPHABLENDENABLE, 1u)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, 2u)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, 1u)); + } + if ( (signed int)uNumVertices > 0 ) + { + v5 = (char *)&arary_77E5C8[0].pos.y; + v6 = (char *)&array_50AC10[0].vWorldViewProjY; + v14 = uNumVertices; + do + { + v7 = *((float *)v6 - 4); + *((int *)v5 - 1) = *((int *)v6 - 1); + v8 = v7; + *(int *)v5 = *(int *)v6; + v9 = *((int *)v6 + 1); + *((int *)v5 + 1) = 0x3F7FF972u; + *((int *)v5 + 2) = v9; + v10 = GetActorTintColor(31, 0, v8, 1, 0); + v11 = *((float *)v6 - 4); + *((int *)v5 + 3) = v10; + v12 = 0; + if ( v4->bUsingSpecular ) + { + v13 = v11; + v12 = sub_47C3D7_get_fog_related_stuff(0, 1, v13); + } + *((int *)v5 + 4) = v12; + *((int *)v5 + 5) = *((int *)v6 + 2); + *((int *)v5 + 6) = *((int *)v6 + 3); + v6 += 48; + v5 += 32; + --v14; + } + while ( v14 ); + } + ErrD3D(pRenderD3D->pDevice->SetTexture(0, a4)); + ErrD3D(pRenderD3D->pDevice->DrawPrimitive( + D3DPT_TRIANGLEFAN, + D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_SPECULAR | D3DFVF_TEX1, + arary_77E5C8, + uNumVertices, + 24)); + } +} + + +//----- (004A2ED5) -------------------------------------------------------- +void Render::_4A2ED5(signed int a2, stru148 *a3, IDirect3DTexture2 *pHwTex) +{ + signed int v4; // edi@2 + int v5; // eax@3 + int v6; // edx@5 + char *v7; // eax@6 + char *v8; // ecx@6 + double v9; // st6@7 + int v10; // ebx@7 + int v11; // ebx@7 + + if ( this->uNumD3DSceneBegins ) + { + v4 = a2; + if ( a2 >= 3 ) + { + ErrD3D(pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_ADDRESS, 1u)); + v5 = 31 - (a3->field_58 & 0x1F); + if ( v5 < pOutdoor->field_CBC_terrain_triangles_shade_type ) + v5 = pOutdoor->field_CBC_terrain_triangles_shade_type; + v6 = 8 * v5 | ((8 * v5 | (v5 << 11)) << 8); + if ( a2 > 0 ) + { + v7 = (char *)&arary_77E5C8[0].pos.y; + v8 = (char *)&array_507D30[0].vWorldViewProjY; + do + { + v9 = *((float *)v8 - 4) * 0.061758894; + v10 = *((int *)v8 - 1); + *((int *)v7 + 4) = 0; + *((int *)v7 - 1) = v10; + *(int *)v7 = *(int *)v8; + *((int *)v7 + 2) = *((int *)v8 + 1); + *((int *)v7 + 5) = *((int *)v8 + 2); + v11 = *((int *)v8 + 3); + *((int *)v7 + 3) = v6; + *((int *)v7 + 6) = v11; + v8 += 48; + v7 += 32; + --v4; + *((float *)v7 - 7) = 1.0 - 1.0 / v9; + } + while ( v4 ); + } + ErrD3D(pRenderD3D->pDevice->SetTexture(0, pHwTex)); + ErrD3D(pRenderD3D->pDevice->DrawPrimitive( + D3DPT_TRIANGLEFAN, + D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_SPECULAR | D3DFVF_TEX1, + arary_77E5C8, + a2, + 28)); + } + } +} + + + +//----- (004A2FC0) -------------------------------------------------------- +void Render::DrawIndoorPolygon(unsigned int uNumVertices, BLVFace *pFace, IDirect3DTexture2 *pHwTex, Texture *pTex, int uPackedID, unsigned int uColor, int a8) +{ + //Render *v8; // edi@1 + //unsigned int v9; // esi@3 + char *v12; // ecx@9 + char *v13; // eax@9 + double v14; // st6@10 + int v15; // edx@10 + Texture *v16; // edx@10 + double v17; // st6@10 + //char v18; // zf@10 + Texture *v19; // edx@10 + Texture *v23; // edx@16 + char *v24; // ecx@16 + char *v25; // eax@16 + double v26; // st6@17 + int v27; // esi@17 + double v28; // st6@17 + unsigned int v33; // ecx@18 + char *v34; // eax@19 + //Texture *v45; // edx@23 + //char *v46; // ecx@23 + //char *v47; // eax@23 + //double v48; // st6@24 + //int v49; // esi@24 + //double v50; // st6@24 + const char *v53; // [sp-Ch] [bp-20h]@21 + //int v54; // [sp-8h] [bp-1Ch]@21 + //unsigned int v55; // [sp-4h] [bp-18h]@21 + const char *v56; // [sp+0h] [bp-14h]@0 + int v57; // [sp+4h] [bp-10h]@0 + unsigned int v58; // [sp+8h] [bp-Ch]@0 + //LightmapBuilder *v59; // [sp+Ch] [bp-8h]@3 + //int a3a; // [sp+10h] [bp-4h]@4 + + //v8 = this; + if (!uNumD3DSceneBegins || uNumVertices < 3) + return; + + //auto a3 = pFace; + //auto a6 = uPackedID; + //v59 = pGame->pLightmapBuilder; + //v9 = v59->std__vector_000004_size; + + auto uCorrectedColor = uColor; + if (pGame->pLightmapBuilder->std__vector_000004_size) + uCorrectedColor = 0xFFFFFFFF; + pGame->AlterGamma(pFace, &uCorrectedColor); + + if (byte_4D864C && pGame->uFlags & 1) + { + __debugbreak(); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ZWRITEENABLE, false)); + ErrD3D(pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_ADDRESS, 1)); + if ( (signed int)uNumVertices > 0 ) + { + v12 = (char *)&array_507D30[0].vWorldViewPosition; + v13 = (char *)&arary_77E5C8[0].pos.y; + auto a7 = uNumVertices; + uint v18; + do + { + v14 = *(float *)v12 * 0.061758894; + v15 = *((int *)v12 + 3); + *((int *)v13 + 4) = 0; + *((int *)v13 - 1) = v15; + *(int *)v13 = *((int *)v12 + 4); + *((int *)v13 + 3) = uCorrectedColor; + v16 = pTex; + v13 += 32; + *((float *)v13 - 7) = 1.0 - 1.0 / v14; + v17 = 1.0 / *(float *)v12; + v12 += 48; + v18 = a7-- == 1; + *((float *)v13 - 6) = v17; + pHwTex = (IDirect3DTexture2 *)v16->uTextureWidth; + v19 = pTex; + *((float *)v13 - 3) = *((float *)v12 - 6) / (double)(signed int)pHwTex; + pHwTex = (IDirect3DTexture2 *)v19->uTextureHeight; + *((float *)v13 - 2) = *((float *)v12 - 5) / (double)(signed int)pHwTex; + } + while ( !v18 ); + } + ErrD3D(pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_ADDRESS, 1)); + ErrD3D(pRenderD3D->pDevice->SetTexture(0, nullptr)); + ErrD3D(pRenderD3D->pDevice->DrawPrimitive( + D3DPT_TRIANGLEFAN, + D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_SPECULAR | D3DFVF_TEX1, + arary_77E5C8, + uNumVertices, + 28)); + pGame->pLightmapBuilder->_45D74F_MessWithLight(-1, 0); + } + else + { + if (!pGame->pLightmapBuilder->std__vector_000004_size || + byte_4D864C && pGame->uFlags & 2) + { + for (uint i = 0; i < uNumVertices; ++i) + { + arary_77E5C8[i].pos.x = array_507D30[i].vWorldViewProjX; + arary_77E5C8[i].pos.y = array_507D30[i].vWorldViewProjY; + arary_77E5C8[i].pos.z = 1.0 - 1.0 / (array_507D30[i].vWorldViewPosition.x * 0.061758894); + arary_77E5C8[i].rhw = 1.0 / array_507D30[i].vWorldViewPosition.x; + arary_77E5C8[i].diffuse = uCorrectedColor; + arary_77E5C8[i].specular = 0; + arary_77E5C8[i].texcoord.x = array_507D30[i].u / (double)pTex->uTextureWidth; + arary_77E5C8[i].texcoord.y = array_507D30[i].v / (double)pTex->uTextureHeight; + } + + ErrD3D(pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_ADDRESS, 1)); + ErrD3D(pRenderD3D->pDevice->SetTexture(0, pHwTex)); + ErrD3D(pRenderD3D->pDevice->DrawPrimitive(D3DPT_TRIANGLEFAN, + D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_SPECULAR | D3DFVF_TEX1, + arary_77E5C8, + uNumVertices, + 28)); + } + else + { + __debugbreak(); + if ( (signed int)uNumVertices > 0 ) + { + v23 = pTex; + v24 = (char *)&array_507D30[0].vWorldViewPosition; + v25 = (char *)&arary_77E5C8[0].pos.y; + pTex = (Texture *)uNumVertices; + uint v18; + do + { + v26 = *(float *)v24 * 0.061758894; + v27 = *((int *)v24 + 3); + *((int *)v25 + 4) = 0; + *((int *)v25 - 1) = v27; + *(int *)v25 = *((int *)v24 + 4); + *((int *)v25 + 3) = uColor; + v25 += 32; + *((float *)v25 - 7) = 1.0 - 1.0 / v26; + v28 = 1.0 / *(float *)v24; + v24 += 48; + v18 = pTex == (Texture *)1; + pTex = (Texture *)((char *)pTex - 1); + *((float *)v25 - 6) = v28; + //a3 = (BLVFace *)v23->uTextureWidth; + *((float *)v25 - 3) = *((float *)v24 - 6) / (double)(signed int)v23->uTextureWidth; + //a3 = (BLVFace *)v23->uTextureHeight; + *((float *)v25 - 2) = *((float *)v24 - 5) / (double)(signed int)v23->uTextureHeight; + } + while ( !v18 ); + } + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ZWRITEENABLE, false)); + ErrD3D(pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_ADDRESS, 1)); + ErrD3D(pRenderD3D->pDevice->SetTexture(0, nullptr)); + ErrD3D(pRenderD3D->pDevice->DrawPrimitive( + D3DPT_TRIANGLEFAN, + D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_SPECULAR | D3DFVF_TEX1, + arary_77E5C8, + uNumVertices, + 28)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_CULLMODE, 1)); + pGame->pLightmapBuilder->_45D74F_MessWithLight(-1, 0); + v33 = uNumVertices; + if ( (signed int)uNumVertices > 0 ) + { + v34 = (char *)&arary_77E5C8[0].diffuse; + do + { + *(int *)v34 = uCorrectedColor; + v34 += 32; + --v33; + } + while ( v33 ); + } + ErrD3D(pRenderD3D->pDevice->SetTexture(0, pHwTex)); + ErrD3D(pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_ADDRESS, 1)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ZWRITEENABLE, 1u)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ALPHABLENDENABLE, true)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, 1)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, 3)); + ErrD3D(pRenderD3D->pDevice->DrawPrimitive( + D3DPT_TRIANGLEFAN, + D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_SPECULAR | D3DFVF_TEX1, + arary_77E5C8, + uNumVertices, + 28)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, 2)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, 1)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ALPHABLENDENABLE, false)); + } + } +} +// 4D864C: using guessed type char byte_4D864C; + + +//----- (004A43B1) -------------------------------------------------------- +void Render::DrawBillboard_Indoor(RenderBillboardTransform_local0 *pSoftBillboard, Sprite *a3, int uPaletteSubindex) +{ + RenderBillboardTransform_local0 *v4; // ebx@2 + double v5; // st7@2 + float v6; // ST08_4@2 + unsigned int v7; // eax@2 + int v8; // ecx@2 + unsigned int v9; // esi@2 + Sprite *v10; // edi@5 + signed int v11; // eax@9 + signed int v12; // eax@9 + double v13; // st7@12 + double v14; // st6@12 + double v15; // st5@12 + double v16; // st4@12 + double v17; // st3@12 + double v18; // st2@12 + int v19; // ecx@14 + double v20; // st3@14 + int v21; // ecx@16 + double v22; // st3@16 + IDirect3DTexture2 *v23; // eax@18 + signed int v24; // [sp+18h] [bp-18h]@5 + signed int v25; // [sp+1Ch] [bp-14h]@5 + Render *v26; // [sp+20h] [bp-10h]@1 + float v27; // [sp+24h] [bp-Ch]@5 + int v28; // [sp+28h] [bp-8h]@2 + float v29; // [sp+2Ch] [bp-4h]@5 + float pSoftBillboarda; // [sp+38h] [bp+8h]@2 + float v31; // [sp+3Ch] [bp+Ch]@5 + float v32; // [sp+3Ch] [bp+Ch]@12 + float a1; // [sp+40h] [bp+10h]@5 + + v26 = this; + if ( this->uNumD3DSceneBegins ) + { + v4 = pSoftBillboard; + v5 = (double)HIWORD(pSoftBillboard->sZValue); + pSoftBillboarda = v5; + v6 = v5; + v7 = Billboard_ProbablyAddToListAndSortByZOrder(LODWORD(v6)); + v8 = uPaletteSubindex; + v9 = v7; + v28 = uPaletteSubindex & 0xFF000000; + if ( uPaletteSubindex & 0xFF000000 ) + pBillboardRenderListD3D[v9].uOpacity = RenderBillboardD3D::Opaque_3; + else + pBillboardRenderListD3D[v9].uOpacity = RenderBillboardD3D::Transparent; + v10 = a3; + pBillboardRenderListD3D[v9].field_90 = v4->field_44; + pBillboardRenderListD3D[v9].sZValue = v4->sZValue; + pBillboardRenderListD3D[v9].uParentBillboardID = v4->uParentBillboardID; + v25 = v4->uScreenSpaceX; + v24 = v4->uScreenSpaceY; + a1 = (double)(v4->field_10 & 0xFFFF) * 0.000015260186 + (double)HIWORD(v4->field_10); + v29 = (double)(v4->field_14 & 0xFFFF) * 0.000015260186 + (double)HIWORD(v4->field_14); + v31 = (double)((v10->uBufferWidth >> 1) - v10->uAreaX); + v27 = (double)(v10->uBufferHeight - v10->uAreaY); + if ( v4->uFlags & 4 ) + v31 = v31 * -1.0; + if ( v4->uTintColor && v26->bTinting ) + { + v11 = GetActorTintColor(v8, 0, pSoftBillboarda, 0, 0); + v12 = sub_4A19D8(v4->uTintColor, v11); + if ( v28 ) + v12 = (unsigned int)((char *)&array_77EC08[1852].pEdgeList1[17] + 3) & ((unsigned int)v12 >> 1); + } + else + { + v12 = GetActorTintColor(v8, 0, pSoftBillboarda, 0, 0); + } + v13 = (double)v25; + pBillboardRenderListD3D[v9].pQuards[0].specular = 0; + pBillboardRenderListD3D[v9].pQuards[0].diffuse = v12; + pBillboardRenderListD3D[v9].pQuards[0].pos.x = v13 - v31 * a1; + v14 = (double)v24; + v32 = v14; + pBillboardRenderListD3D[v9].pQuards[0].pos.y = v14 - v27 * v29; + v15 = 1.0 - 1.0 / (pSoftBillboarda * 0.061758894); + pBillboardRenderListD3D[v9].pQuards[0].pos.z = v15; + v16 = 1.0 / pSoftBillboarda; + pBillboardRenderListD3D[v9].pQuards[0].rhw = 1.0 / pSoftBillboarda; + pBillboardRenderListD3D[v9].pQuards[0].texcoord.x = 0.0; + pBillboardRenderListD3D[v9].pQuards[0].texcoord.y = 0.0; + v17 = (double)((v10->uBufferWidth >> 1) - v10->uAreaX); + v18 = (double)(v10->uBufferHeight - v10->uAreaY - v10->uAreaHeight); + if ( v4->uFlags & 4 ) + v17 = v17 * -1.0; + pBillboardRenderListD3D[v9].pQuards[1].specular = 0; + pBillboardRenderListD3D[v9].pQuards[1].diffuse = v12; + pBillboardRenderListD3D[v9].pQuards[1].pos.x = v13 - v17 * a1; + pBillboardRenderListD3D[v9].pQuards[1].pos.y = v32 - v18 * v29; + pBillboardRenderListD3D[v9].pQuards[1].pos.z = v15; + pBillboardRenderListD3D[v9].pQuards[1].rhw = v16; + pBillboardRenderListD3D[v9].pQuards[1].texcoord.x = 0.0; + pBillboardRenderListD3D[v9].pQuards[1].texcoord.y = 1.0; + v19 = v10->uBufferHeight - v10->uAreaY - v10->uAreaHeight; + v20 = (double)(v10->uAreaX + v10->uAreaWidth + (v10->uBufferWidth >> 1) - v10->uBufferWidth); + if ( v4->uFlags & 4 ) + v20 = v20 * -1.0; + pBillboardRenderListD3D[v9].pQuards[2].specular = 0; + pBillboardRenderListD3D[v9].pQuards[2].diffuse = v12; + pBillboardRenderListD3D[v9].pQuards[2].pos.x = v20 * a1 + v13; + pBillboardRenderListD3D[v9].pQuards[2].pos.y = v32 - (double)v19 * v29; + pBillboardRenderListD3D[v9].pQuards[2].pos.z = v15; + pBillboardRenderListD3D[v9].pQuards[2].rhw = v16; + pBillboardRenderListD3D[v9].pQuards[2].texcoord.x = 1.0; + pBillboardRenderListD3D[v9].pQuards[2].texcoord.y = 1.0; + v21 = v10->uBufferHeight - v10->uAreaY; + v22 = (double)(v10->uAreaX + v10->uAreaWidth + (v10->uBufferWidth >> 1) - v10->uBufferWidth); + if ( v4->uFlags & 4 ) + v22 = v22 * -1.0; + pBillboardRenderListD3D[v9].pQuards[3].specular = 0; + pBillboardRenderListD3D[v9].pQuards[3].diffuse = v12; + pBillboardRenderListD3D[v9].pQuards[3].pos.x = v22 * a1 + v13; + pBillboardRenderListD3D[v9].pQuards[3].pos.y = v32 - (double)v21 * v29; + pBillboardRenderListD3D[v9].pQuards[3].pos.z = v15; + pBillboardRenderListD3D[v9].pQuards[3].rhw = v16; + pBillboardRenderListD3D[v9].pQuards[3].texcoord.x = 1.0; + pBillboardRenderListD3D[v9].pQuards[3].texcoord.y = 0.0; + v23 = v10->pTexture; + pBillboardRenderListD3D[v9].uNumVertices = 4; + pBillboardRenderListD3D[v9].flt_88 = pSoftBillboarda; + pBillboardRenderListD3D[v9].pTexture = v23; + } +} + + + +//----- (004A354F) -------------------------------------------------------- +void Render::MakeParticleBillboardAndPush_BLV(RenderBillboardTransform_local0 *a2, IDirect3DTexture2 *a3, unsigned int uDiffuse, int angle) +{ + double v5; // st7@3 + float v6; // ST20_4@3 + float v7; // ST00_4@3 + unsigned int v8; // esi@3 + int v9; // eax@3 + int v10; // ebx@3 + float v11; // ST28_4@3 + double v12; // st7@3 + float v13; // ST24_4@3 + double v14; // st6@3 + float v15; // ST1C_4@3 + float v16; // ST2C_4@3 + float v17; // ST30_4@3 + signed int v18; // ST18_4@3 + signed int v19; // ST14_4@3 + signed int v20; // ST10_4@3 + signed int v21; // eax@3 + double v22; // st6@3 + float v23; // ST2C_4@3 + float v24; // ST30_4@3 + signed int v25; // ST10_4@3 + signed int v26; // ST14_4@3 + signed int v27; // ST18_4@3 + signed int v28; // eax@3 + double v29; // st6@3 + float v30; // ecx@3 + float v31; // ST2C_4@3 + float v32; // ST30_4@3 + signed int v33; // ST10_4@3 + signed int v34; // ST14_4@3 + signed int v35; // ST18_4@3 + signed int v36; // eax@3 + float v37; // ecx@3 + double v38; // st6@3 + float v39; // ST2C_4@3 + float v40; // ST30_4@3 + signed int v41; // ST10_4@3 + signed int v42; // ST14_4@3 + signed int v43; // ST18_4@3 + signed int v44; // eax@3 + double v45; // st6@3 + float v46; // eax@3 + + if ( this->uNumD3DSceneBegins ) + { + if ( HIWORD(a2->sZValue) ) + { + v5 = (double)HIWORD(a2->sZValue); + v6 = v5; + v7 = v5; + v8 = Billboard_ProbablyAddToListAndSortByZOrder(LODWORD(v7)); + pBillboardRenderListD3D[v8].uOpacity = RenderBillboardD3D::Opaque_1; + pBillboardRenderListD3D[v8].field_90 = a2->field_44; + pBillboardRenderListD3D[v8].sZValue = a2->sZValue; + pBillboardRenderListD3D[v8].uParentBillboardID = a2->uParentBillboardID; + v9 = a2->uScreenSpaceX; + v10 = a2->uScreenSpaceY; + v11 = (double)(a2->field_10 & 0xFFFF) * 0.000015260186 + (double)HIWORD(a2->field_10); + v12 = (double)v9; + v13 = v12; + v14 = (double)(v10 - 12); + v15 = v14; + v16 = (double)(v9 - 12) - v12; + v17 = (double)(v10 - 25) - v14; + v18 = stru_5C6E00->SinCos(angle); + v19 = stru_5C6E00->SinCos(angle - stru_5C6E00->uIntegerHalfPi); + v20 = stru_5C6E00->SinCos(angle - stru_5C6E00->uIntegerHalfPi); + v21 = stru_5C6E00->SinCos(angle); + pBillboardRenderListD3D[v8].pQuards[0].pos.x = (((double)(unsigned __int16)v18 * 0.000015259022 + + (double)(v18 >> 16)) + * v16 + - ((double)(unsigned __int16)v19 * 0.000015259022 + + (double)(v19 >> 16)) + * v17) + * v11 + v13; + v22 = (((double)(unsigned __int16)v21 * 0.000015259022 + (double)(v21 >> 16)) * v17 + + ((double)(unsigned __int16)v20 * 0.000015259022 + (double)(v20 >> 16)) * v16 + - 12.0) + * v11 + + (double)a2->uScreenSpaceY; + pBillboardRenderListD3D[v8].pQuards[0].specular = 0; + pBillboardRenderListD3D[v8].pQuards[0].diffuse = uDiffuse; + pBillboardRenderListD3D[v8].pQuards[0].pos.y = v22; + pBillboardRenderListD3D[v8].pQuards[0].pos.z = 1.0 - 1.0 / (v6 * 0.061758894); + pBillboardRenderListD3D[v8].pQuards[0].rhw = 1.0 / v6; + pBillboardRenderListD3D[v8].pQuards[0].texcoord.x = 0.0; + pBillboardRenderListD3D[v8].pQuards[0].texcoord.y = 0.0; + v31 = (double)(a2->uScreenSpaceX + 12) - v13; + v32 = (double)a2->uScreenSpaceY - v15; + v25 = stru_5C6E00->SinCos(angle); + v26 = stru_5C6E00->SinCos(angle - stru_5C6E00->uIntegerHalfPi); + v27 = stru_5C6E00->SinCos(angle - stru_5C6E00->uIntegerHalfPi); + v28 = stru_5C6E00->SinCos(angle); + pBillboardRenderListD3D[v8].pQuards[1].pos.x = (((double)(unsigned __int16)v25 * 0.000015259022 + + (double)(v25 >> 16)) + * v23 + - ((double)(unsigned __int16)v26 * 0.000015259022 + + (double)(v26 >> 16)) + * v24) + * v11 + v13; + v29 = (((double)(unsigned __int16)v28 * 0.000015259022 + (double)(v28 >> 16)) * v24 + + ((double)(unsigned __int16)v27 * 0.000015259022 + (double)(v27 >> 16)) * v23 + - 12.0) + * v11 + + (double)a2->uScreenSpaceY; + pBillboardRenderListD3D[v8].pQuards[1].pos.z = pRenderer->pBillboardRenderListD3D[v8].pQuards[0].pos.z; + v30 = pBillboardRenderListD3D[v8].pQuards[0].rhw; + pBillboardRenderListD3D[v8].pQuards[1].pos.y = v29; + pBillboardRenderListD3D[v8].pQuards[1].specular = 0; + pBillboardRenderListD3D[v8].pQuards[1].rhw = v30; + pBillboardRenderListD3D[v8].pQuards[1].diffuse = uDiffuse; + pBillboardRenderListD3D[v8].pQuards[1].texcoord.x = 0.0; + pBillboardRenderListD3D[v8].pQuards[1].texcoord.y = 1.0; + v23 = (double)(a2->uScreenSpaceX - 12) - v13; + v24 = (double)a2->uScreenSpaceY - v15; + v33 = stru_5C6E00->SinCos(angle); + v34 = stru_5C6E00->SinCos(angle - stru_5C6E00->uIntegerHalfPi); + v35 = stru_5C6E00->SinCos(angle - stru_5C6E00->uIntegerHalfPi); + v36 = stru_5C6E00->SinCos(angle); + pBillboardRenderListD3D[v8].pQuards[2].pos.x = (((double)(unsigned __int16)v33 * 0.000015259022 + + (double)(v33 >> 16)) + * v31 + - ((double)(unsigned __int16)v34 * 0.000015259022 + + (double)(v34 >> 16)) + * v32) + * v11 + v13; + v37 = pBillboardRenderListD3D[v8].pQuards[0].pos.z; + v38 = (((double)(unsigned __int16)v36 * 0.000015259022 + (double)(v36 >> 16)) * v32 + + ((double)(unsigned __int16)v35 * 0.000015259022 + (double)(v35 >> 16)) * v31 + - 12.0) + * v11 + + (double)a2->uScreenSpaceY; + pBillboardRenderListD3D[v8].pQuards[2].specular = 0; + pBillboardRenderListD3D[v8].pQuards[2].pos.z = v37; + pBillboardRenderListD3D[v8].pQuards[2].rhw = pBillboardRenderListD3D[v8].pQuards[0].rhw; + pBillboardRenderListD3D[v8].pQuards[2].diffuse = uDiffuse; + pBillboardRenderListD3D[v8].pQuards[2].pos.y = v38; + pBillboardRenderListD3D[v8].pQuards[2].texcoord.x = 1.0; + pBillboardRenderListD3D[v8].pQuards[2].texcoord.y = 1.0; + v39 = (double)(a2->uScreenSpaceX + 12) - v13; + v40 = (double)(a2->uScreenSpaceY - 25) - v15; + v41 = stru_5C6E00->SinCos(angle); + v42 = stru_5C6E00->SinCos(angle - stru_5C6E00->uIntegerHalfPi); + v43 = stru_5C6E00->SinCos(angle - stru_5C6E00->uIntegerHalfPi); + v44 = stru_5C6E00->SinCos(angle); + pBillboardRenderListD3D[v8].pQuards[3].pos.x = (((double)(unsigned __int16)v41 * 0.000015259022 + + (double)(v41 >> 16)) + * v39 + - ((double)(unsigned __int16)v42 * 0.000015259022 + + (double)(v42 >> 16)) + * v40) + * v11 + v13; + v45 = (((double)(unsigned __int16)v44 * 0.000015259022 + (double)(v44 >> 16)) * v40 + + ((double)(unsigned __int16)v43 * 0.000015259022 + (double)(v43 >> 16)) * v39 + - 12.0) + * v11 + + (double)a2->uScreenSpaceY; + v46 = pBillboardRenderListD3D[v8].pQuards[0].pos.z; + pBillboardRenderListD3D[v8].pQuards[3].specular = 0; + pBillboardRenderListD3D[v8].pQuards[3].pos.z = v46; + pBillboardRenderListD3D[v8].pQuards[3].rhw = pBillboardRenderListD3D[v8].pQuards[0].rhw; + pBillboardRenderListD3D[v8].pQuards[3].diffuse = uDiffuse; + pBillboardRenderListD3D[v8].pTexture = a3; + pBillboardRenderListD3D[v8].flt_88 = v6; + pBillboardRenderListD3D[v8].uNumVertices = 4; + pBillboardRenderListD3D[v8].pQuards[3].pos.y = v45; + pBillboardRenderListD3D[v8].pQuards[3].texcoord.x = 1.0; + pBillboardRenderListD3D[v8].pQuards[3].texcoord.y = 0.0; + } + } +} + + +//----- (004A3AD9) -------------------------------------------------------- +void Render::MakeParticleBillboardAndPush_ODM(RenderBillboardTransform_local0 *a2, IDirect3DTexture2 *a3, unsigned int uDiffuse, int angle) +{ + double v5; // st7@2 + float v6; // ST28_4@2 + float v7; // ST00_4@2 + unsigned int v8; // esi@2 + int v9; // eax@2 + int v10; // ebx@2 + float v11; // ST34_4@2 + double v12; // st7@2 + float v13; // ST2C_4@2 + double v14; // st6@2 + float v15; // ST24_4@2 + float v16; // ST38_4@2 + float v17; // ST3C_4@2 + signed int v18; // ST1C_4@2 + int v19; // ST30_4@2 + signed int v20; // ST20_4@2 + signed int v21; // ST18_4@2 + signed int v22; // eax@2 + double v23; // st6@2 + float v24; // ST20_4@2 + float v25; // ST1C_4@2 + float v26; // ST38_4@2 + float v27; // ST3C_4@2 + signed int v28; // ST18_4@2 + signed int v29; // ST14_4@2 + signed int v30; // ST10_4@2 + signed int v31; // eax@2 + double v32; // st6@2 + float v33; // ST38_4@2 + float v34; // ST3C_4@2 + signed int v35; // ST10_4@2 + signed int v36; // ST14_4@2 + signed int v37; // ST18_4@2 + signed int v38; // eax@2 + double v39; // st6@2 + float v40; // ST38_4@2 + float v41; // ST3C_4@2 + signed int v42; // ST10_4@2 + signed int v43; // ST14_4@2 + signed int v44; // ST18_4@2 + signed int v45; // eax@2 + double v46; // st6@2 + + if ( this->uNumD3DSceneBegins ) + { + v5 = (double)HIWORD(a2->sZValue); + v6 = v5; + v7 = v5; + v8 = Billboard_ProbablyAddToListAndSortByZOrder(LODWORD(v7)); + pBillboardRenderListD3D[v8].uOpacity = RenderBillboardD3D::Opaque_1; + pBillboardRenderListD3D[v8].field_90 = a2->field_44; + pBillboardRenderListD3D[v8].sZValue = a2->sZValue; + pBillboardRenderListD3D[v8].uParentBillboardID = a2->uParentBillboardID; + v9 = a2->uScreenSpaceX; + v10 = a2->uScreenSpaceY; + v11 = (double)(a2->field_10 & 0xFFFF) * 0.000015260186 + (double)HIWORD(a2->field_10); + v12 = (double)v9; + v13 = v12; + v14 = (double)(v10 - 12); + v15 = v14; + v16 = (double)(v9 - 12) - v12; + v17 = (double)(v10 - 25) - v14; + v18 = stru_5C6E00->SinCos(angle); + v19 = angle - stru_5C6E00->uIntegerHalfPi; + v20 = stru_5C6E00->SinCos(angle - stru_5C6E00->uIntegerHalfPi); + v21 = stru_5C6E00->SinCos(v19); + v22 = stru_5C6E00->SinCos(angle); + pBillboardRenderListD3D[v8].pQuards[0].pos.x = (((double)(unsigned __int16)v18 * 0.000015259022 + + (double)(v18 >> 16)) + * v16 + - ((double)(unsigned __int16)v20 * 0.000015259022 + + (double)(v20 >> 16)) + * v17) + * v11 + v13; + v23 = (((double)(unsigned __int16)v22 * 0.000015259022 + (double)(v22 >> 16)) * v17 + + ((double)(unsigned __int16)v21 * 0.000015259022 + (double)(v21 >> 16)) * v16 + - 12.0) + * v11 + + (double)a2->uScreenSpaceY; + pBillboardRenderListD3D[v8].pQuards[0].specular = 0; + pBillboardRenderListD3D[v8].pQuards[0].diffuse = uDiffuse; + pBillboardRenderListD3D[v8].pQuards[0].pos.y = v23; + v24 = 1.0 - 1.0 / (v6 * 1000.0 / (double)pOutdoorCamera->shading_dist_mist); + pBillboardRenderListD3D[v8].pQuards[0].pos.z = v24; + v25 = 1.0 / v6; + pBillboardRenderListD3D[v8].pQuards[0].rhw = v25; + pBillboardRenderListD3D[v8].pQuards[0].texcoord.x = 0.0; + pBillboardRenderListD3D[v8].pQuards[0].texcoord.y = 0.0; + v26 = (double)(a2->uScreenSpaceX - 12) - v13; + v27 = (double)a2->uScreenSpaceY - v15; + v28 = stru_5C6E00->SinCos(angle); + v29 = stru_5C6E00->SinCos(v19); + v30 = stru_5C6E00->SinCos(v19); + v31 = stru_5C6E00->SinCos(angle); + pBillboardRenderListD3D[v8].pQuards[1].pos.x = (((double)(unsigned __int16)v28 * 0.000015259022 + + (double)(v28 >> 16)) + * v26 + - ((double)(unsigned __int16)v29 * 0.000015259022 + + (double)(v29 >> 16)) + * v27) + * v11 + v13; + v32 = (((double)(unsigned __int16)v31 * 0.000015259022 + (double)(v31 >> 16)) * v27 + + ((double)(unsigned __int16)v30 * 0.000015259022 + (double)(v30 >> 16)) * v26 + - 12.0) + * v11 + + (double)a2->uScreenSpaceY; + pBillboardRenderListD3D[v8].pQuards[1].pos.z = v24; + pBillboardRenderListD3D[v8].pQuards[1].pos.y = v32; + pBillboardRenderListD3D[v8].pQuards[1].specular = 0; + pBillboardRenderListD3D[v8].pQuards[1].rhw = v25; + pBillboardRenderListD3D[v8].pQuards[1].diffuse = uDiffuse; + pBillboardRenderListD3D[v8].pQuards[1].texcoord.x = 0.0; + pBillboardRenderListD3D[v8].pQuards[1].texcoord.y = 1.0; + v33 = (double)(a2->uScreenSpaceX + 12) - v13; + v34 = (double)a2->uScreenSpaceY - v15; + v35 = stru_5C6E00->SinCos(angle); + v36 = stru_5C6E00->SinCos(v19); + v37 = stru_5C6E00->SinCos(v19); + v38 = stru_5C6E00->SinCos(angle); + pBillboardRenderListD3D[v8].pQuards[2].pos.x = (((double)(unsigned __int16)v35 * 0.000015259022 + + (double)(v35 >> 16)) + * v33 + - ((double)(unsigned __int16)v36 * 0.000015259022 + + (double)(v36 >> 16)) + * v34) + * v11 + v13; + v39 = (((double)(unsigned __int16)v38 * 0.000015259022 + (double)(v38 >> 16)) * v34 + + ((double)(unsigned __int16)v37 * 0.000015259022 + (double)(v37 >> 16)) * v33 + - 12.0) + * v11 + + (double)a2->uScreenSpaceY; + pBillboardRenderListD3D[v8].pQuards[2].specular = 0; + pBillboardRenderListD3D[v8].pQuards[2].pos.z = v24; + pBillboardRenderListD3D[v8].pQuards[2].rhw = v25; + pBillboardRenderListD3D[v8].pQuards[2].diffuse = uDiffuse; + pBillboardRenderListD3D[v8].pQuards[2].pos.y = v39; + pBillboardRenderListD3D[v8].pQuards[2].texcoord.x = 1.0; + pBillboardRenderListD3D[v8].pQuards[2].texcoord.y = 1.0; + v40 = (double)(a2->uScreenSpaceX + 12) - v13; + v41 = (double)(a2->uScreenSpaceY - 25) - v15; + v42 = stru_5C6E00->SinCos(angle); + v43 = stru_5C6E00->SinCos(v19); + v44 = stru_5C6E00->SinCos(v19); + v45 = stru_5C6E00->SinCos(angle); + pBillboardRenderListD3D[v8].pQuards[3].pos.x = (((double)(unsigned __int16)v42 * 0.000015259022 + + (double)(v42 >> 16)) + * v40 + - ((double)(unsigned __int16)v43 * 0.000015259022 + + (double)(v43 >> 16)) + * v41) + * v11 + v13; + v46 = (((double)(unsigned __int16)v45 * 0.000015259022 + (double)(v45 >> 16)) * v41 + + ((double)(unsigned __int16)v44 * 0.000015259022 + (double)(v44 >> 16)) * v40 + - 12.0) + * v11 + + (double)a2->uScreenSpaceY; + pBillboardRenderListD3D[v8].pQuards[3].specular = 0; + pBillboardRenderListD3D[v8].pQuards[3].pos.z = v24; + pBillboardRenderListD3D[v8].pQuards[3].rhw = v25; + pBillboardRenderListD3D[v8].pQuards[3].diffuse = uDiffuse; + pBillboardRenderListD3D[v8].pTexture = a3; + pBillboardRenderListD3D[v8].flt_88 = v6; + pBillboardRenderListD3D[v8].uNumVertices = 4; + pBillboardRenderListD3D[v8].pQuards[3].pos.y = v46; + pBillboardRenderListD3D[v8].pQuards[3].texcoord.x = 1.0; + pBillboardRenderListD3D[v8].pQuards[3].texcoord.y = 0.0; + } +} + + +//----- (004A4023) -------------------------------------------------------- +void Render::TransformBillboard(RenderBillboardTransform_local0 *a2, Sprite *pSprite, int a1a, RenderBillboard *pBillboard) +{ + RenderBillboardTransform_local0 *v5; // ebx@2 + double v6; // st7@2 + float v7; // ST08_4@2 + unsigned int v8; // esi@2 + Sprite *v9; // edi@5 + signed int v10; // eax@9 + signed int v11; // eax@9 + int v12; // eax@12 + double v13; // st7@12 + double v14; // st6@14 + double v15; // st5@14 + unsigned int v16; // ecx@16 + double v17; // st7@16 + double v18; // st5@16 + double v19; // st4@16 + double v20; // st5@18 + double v21; // st4@18 + IDirect3DTexture2 *v22; // eax@20 + signed int v23; // [sp+18h] [bp-18h]@5 + signed int v24; // [sp+1Ch] [bp-14h]@5 + float v25; // [sp+1Ch] [bp-14h]@12 + float v26; // [sp+20h] [bp-10h]@5 + float v27; // [sp+20h] [bp-10h]@12 + Render *a3; // [sp+24h] [bp-Ch]@1 + float v29; // [sp+28h] [bp-8h]@5 + float v30; // [sp+2Ch] [bp-4h]@5 + float v31; // [sp+38h] [bp+8h]@2 + float pSpritea; // [sp+3Ch] [bp+Ch]@5 + float a1b; // [sp+40h] [bp+10h]@12 + float pBillboarda; // [sp+44h] [bp+14h]@12 + + auto a1 = this; + a3 = a1; + if ( a1->uNumD3DSceneBegins ) + { + v5 = a2; + v6 = (double)HIWORD(a2->sZValue); + v31 = v6; + v7 = v6; + v8 = Billboard_ProbablyAddToListAndSortByZOrder(LODWORD(v7)); + if ( BYTE3(v5->uTintColor) ) + pBillboardRenderListD3D[v8].uOpacity = RenderBillboardD3D::Opaque_3; + else + pBillboardRenderListD3D[v8].uOpacity = RenderBillboardD3D::Transparent; + v9 = pSprite; + pBillboardRenderListD3D[v8].field_90 = v5->field_44; + pBillboardRenderListD3D[v8].sZValue = v5->sZValue; + pBillboardRenderListD3D[v8].uParentBillboardID = v5->uParentBillboardID; + v24 = v5->uScreenSpaceX; + v23 = v5->uScreenSpaceY; + v30 = (double)(v5->field_10 & 0xFFFF) * 0.000015260186 + (double)HIWORD(v5->field_10); + v29 = (double)(v5->field_14 & 0xFFFF) * 0.000015260186 + (double)HIWORD(v5->field_14); + pSpritea = (double)((v9->uBufferWidth >> 1) - v9->uAreaX); + v26 = (double)(v9->uBufferHeight - v9->uAreaY); + if ( v5->uFlags & 4 ) + pSpritea = pSpritea * -1.0; + if ( v5->uTintColor & 0xFFFFFF && a3->bTinting ) + { + v10 = GetActorTintColor(a1a, 0, v31, 0, pBillboard); + v11 = sub_4A19D8(v5->uTintColor, v10); + if ( BYTE3(v5->uTintColor) ) + v11 = (unsigned int)((char *)&array_77EC08[1852].pEdgeList1[17] + 3) & ((unsigned int)v11 >> 1); + } + else + { + v11 = GetActorTintColor(a1a, 0, v31, 0, pBillboard); + } + pBillboardRenderListD3D[v8].pQuards[0].diffuse = v11; + v12 = 0; + pBillboarda = (double)v24; + pBillboardRenderListD3D[v8].pQuards[0].pos.x = pBillboarda - pSpritea * v30; + a1b = (double)v23; + pBillboardRenderListD3D[v8].pQuards[0].pos.y = a1b - v26 * v29; + v27 = v31 * 1000.0; + v13 = 1.0; + pBillboardRenderListD3D[v8].pQuards[0].pos.z = 1.0 + - 1.0 / (v27 / (double)pOutdoorCamera->shading_dist_mist); + v25 = 1.0 / v31; + pBillboardRenderListD3D[v8].pQuards[0].rhw = v25; + if ( a3->bUsingSpecular ) + { + v12 = sub_47C3D7_get_fog_related_stuff(0, 0, v31); + v13 = 1.0; + } + pBillboardRenderListD3D[v8].pQuards[0].specular = v12; + pBillboardRenderListD3D[v8].pQuards[0].texcoord.x = 0.0; + pBillboardRenderListD3D[v8].pQuards[0].texcoord.y = 0.0; + v14 = (double)((v9->uBufferWidth >> 1) - v9->uAreaX); + v15 = (double)(v9->uBufferHeight - v9->uAreaHeight - v9->uAreaY); + if ( v5->uFlags & 4 ) + v14 = v14 * -1.0; + v16 = pBillboardRenderListD3D[v8].pQuards[0].diffuse; + pBillboardRenderListD3D[v8].pQuards[1].specular = v12; + pBillboardRenderListD3D[v8].pQuards[1].diffuse = v16; + pBillboardRenderListD3D[v8].pQuards[1].pos.x = pBillboarda - v14 * v30; + pBillboardRenderListD3D[v8].pQuards[1].pos.y = a1b - v15 * v29; + v17 = v13 - v13 / (v27 / (double)pOutdoorCamera->shading_dist_mist); + pBillboardRenderListD3D[v8].pQuards[1].pos.z = v17; + pBillboardRenderListD3D[v8].pQuards[1].rhw = v25; + pBillboardRenderListD3D[v8].pQuards[1].texcoord.x = 0.0; + pBillboardRenderListD3D[v8].pQuards[1].texcoord.y = 1.0; + v18 = (double)(v9->uAreaWidth + v9->uAreaX + (v9->uBufferWidth >> 1) - v9->uBufferWidth); + v19 = (double)(v9->uBufferHeight - v9->uAreaHeight - v9->uAreaY); + if ( v5->uFlags & 4 ) + v18 = v18 * -1.0; + pBillboardRenderListD3D[v8].pQuards[2].diffuse = v16; + pBillboardRenderListD3D[v8].pQuards[2].specular = v12; + pBillboardRenderListD3D[v8].pQuards[2].pos.x = v18 * v30 + pBillboarda; + pBillboardRenderListD3D[v8].pQuards[2].pos.y = a1b - v19 * v29; + pBillboardRenderListD3D[v8].pQuards[2].pos.z = v17; + pBillboardRenderListD3D[v8].pQuards[2].rhw = v25; + pBillboardRenderListD3D[v8].pQuards[2].texcoord.x = 1.0; + pBillboardRenderListD3D[v8].pQuards[2].texcoord.y = 1.0; + v20 = (double)(v9->uAreaWidth + v9->uAreaX + (v9->uBufferWidth >> 1) - v9->uBufferWidth); + v21 = (double)(v9->uBufferHeight - v9->uAreaY); + if ( v5->uFlags & 4 ) + v20 = v20 * -1.0; + pBillboardRenderListD3D[v8].pQuards[3].diffuse = v16; + pBillboardRenderListD3D[v8].pQuards[3].specular = v12; + pBillboardRenderListD3D[v8].pQuards[3].pos.x = v20 * v30 + pBillboarda; + pBillboardRenderListD3D[v8].pQuards[3].pos.y = a1b - v21 * v29; + pBillboardRenderListD3D[v8].pQuards[3].pos.z = v17; + pBillboardRenderListD3D[v8].pQuards[3].rhw = v25; + pBillboardRenderListD3D[v8].pQuards[3].texcoord.x = 1.0; + pBillboardRenderListD3D[v8].pQuards[3].texcoord.y = 0.0; + v22 = v9->pTexture; + pBillboardRenderListD3D[v8].uNumVertices = 4; + pBillboardRenderListD3D[v8].pTexture = v22; + pBillboardRenderListD3D[v8].flt_88 = v31; + } +} + + +//----- (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 v10; // eax@1 + unsigned int v11; // ebx@1 + unsigned int v12; // ecx@1 + int v13; // edx@2 + int v14; // edx@4 + unsigned int v15; // edx@6 + double v16; // st7@7 + double v17; // st7@7 + double v18; // st6@7 + double v19; // st4@7 + double v20; // st4@8 + double v21; // st4@10 + double v22; // st4@10 + double v23; // st4@10 + double v24; // st4@10 + double v25; // st4@11 + double v26; // st4@13 + double v27; // st5@13 + double v28; // st4@13 + RenderVertexD3D3 v29[4]; // [sp+0h] [bp-94h]@7 + double v30; // [sp+80h] [bp-14h]@1 + int v31; // [sp+88h] [bp-Ch]@1 + signed int v32; // [sp+8Ch] [bp-8h]@1 + int X; // [sp+90h] [bp-4h]@1 + float a3a; // [sp+A4h] [bp+10h]@10 + float a4a; // [sp+A8h] [bp+14h]@10 + + *(float *)&X = dstX - srcX; + v30 = *(float *)&X + 6.7553994e15; + v31 = LODWORD(v30); + *(float *)&v32 = dstY - srcY; + v30 = *(float *)&v32 + 6.7553994e15; + X = LODWORD(v30); + HIDWORD(v30) = abs(COERCE_UNSIGNED_INT64(*(float *)&v32 + 6.7553994e15)); + v10 = abs(v31); + v32 = v10; + v11 = HIDWORD(v30); + v12 = 0; + if ( v10 < SHIDWORD(v30) ) + { + v13 = v10; + v10 = HIDWORD(v30); + v11 = v13; + } + if ( v10 < 0 ) + { + v14 = v10; + v10 = 0; + v12 = v14; + } + if ( (signed int)v11 < (signed int)v12 ) + { + v15 = v12; + v12 = v11; + v11 = v15; + } + v32 = (11 * v11 >> 5) + (v12 >> 2) + v10; + v16 = 1.0 / (double)v32; + *(float *)&v31 = (double)v31 * v16; + *(float *)&X = (double)X * v16; + v17 = *(float *)&X * a4; + v29[0].pos.x = srcX + v17; + v18 = *(float *)&v31 * a4; + v29[0].pos.y = srcY - v18; + v19 = a3; + if ( uCurrentlyLoadedLevelType == LEVEL_Outdoor ) + v20 = v19 * 1000.0 / (double)pOutdoorCamera->shading_dist_mist; + else + v20 = v19 * 0.061758894; + v29[0].diffuse = -1; + v29[0].specular = 0; + v29[0].pos.z = 1.0 - 1.0 / v20; + v21 = 1.0 / a3; + *((float *)&v30 + 1) = v21; + v29[0].rhw = v21; + v29[0].texcoord.x = 1.0; + v29[0].texcoord.y = 0.0; + v22 = *(float *)&X * a8; + a3a = v22; + v29[1].pos.x = v22 + dstX; + v23 = *(float *)&v31 * a8; + a4a = v23; + v29[1].pos.y = dstY - v23; + v24 = a7; + if ( uCurrentlyLoadedLevelType == LEVEL_Outdoor ) + v25 = v24 * 1000.0 / (double)pOutdoorCamera->shading_dist_mist; + else + v25 = v24 * 0.061758894; + v29[2].diffuse = -1; + v29[3].diffuse = -1; + *(_QWORD *)&v29[3].pos.z = __PAIR__(HIDWORD(v30), LODWORD(v29[0].pos.z)); + v29[1].diffuse = -16711936; + v29[1].specular = 0; + v29[2].specular = 0; + v29[3].specular = 0; + v26 = 1.0 - 1.0 / v25; + v29[1].pos.z = v26; + v27 = v26; + v28 = 1.0 / a7; + v29[1].rhw = v28; + v29[1].texcoord.x = 1.0; + v29[1].texcoord.y = 1.0; + v29[2].pos.x = dstX - a3a; + v29[2].pos.y = a4a + dstY; + v29[2].pos.z = v27; + v29[2].rhw = v28; + v29[2].texcoord.x = 0.0; + v29[2].texcoord.y = 1.0; + v29[3].pos.x = srcX - v17; + v29[3].pos.y = v18 + srcY; + v29[3].texcoord.x = 0.0; + v29[3].texcoord.y = 0.0; + ErrD3D(pRenderer->pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ALPHABLENDENABLE, 1u)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, 2u)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, 2u)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_DITHERENABLE, 0)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ZWRITEENABLE, 0)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_CULLMODE, 1u)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetTexture(0, a9)); + ErrD3D(pRenderer->pRenderD3D->pDevice->DrawPrimitive( + D3DPT_TRIANGLEFAN, + D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_SPECULAR | D3DFVF_TEX1, + v29, + 4, + 24)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ALPHABLENDENABLE, 0)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, 2u)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, 1u)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_DITHERENABLE, 1u)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ZWRITEENABLE, 1u)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_CULLMODE, 2u)); +} + + +//----- (004A4CC9) -------------------------------------------------------- +void Render::_4A4CC9(stru6_stru1_indoor_sw_billboard *a1, int a2) +{ + int v3; // eax@1 + int v4; // edx@3 + unsigned int v5; // eax@7 + int v6; // edi@7 + char *v7; // edx@8 + char *v8; // ecx@8 + char v9; // zf@9 + double v10; // st6@9 + double v11; // st6@10 + int v12; // ebx@13 + int v13; // ecx@16 + unsigned int v14; // [sp+Ch] [bp-4h]@1 + + auto _this = this; + + *(float *)&v14 = 1000000.0; + v3 = a1->field_10; + if ( v3 >= 3 ) + { + if ( v3 > 0 ) + { + _this = (Render *)&a1->field_14[62]; + v4 = a1->field_10; + do + { + if ( *(float *)&this->bUserDirect3D < (double)*(float *)&v14 ) + v14 = this->bUserDirect3D; + _this = (Render *)((char *)_this + 16); + --v4; + } + while ( v4 ); + } + v5 = Billboard_ProbablyAddToListAndSortByZOrder(v14); + v6 = 0; + pBillboardRenderListD3D[v5].field_90 = 0; + pBillboardRenderListD3D[v5].uParentBillboardID = -1; + pBillboardRenderListD3D[v5].uOpacity = RenderBillboardD3D::Opaque_2; + if ( a1->field_10 > 0 ) + { + v7 = (char *)&a1->field_14[62]; + v8 = (char *)&pBillboardRenderListD3D[v5].pQuards[0].pos.z; + do + { + v9 = uCurrentlyLoadedLevelType == LEVEL_Indoor; + *((int *)v8 - 2) = *((int *)v7 - 2); + *((int *)v8 - 1) = *((int *)v7 - 1); + v10 = *(float *)v7; + if ( v9 ) + v11 = v10 * 0.061758894; + else + v11 = v10 * 1000.0 / (double)pOutdoorCamera->shading_dist_mist; + *(float *)v8 = 1.0 - 1.0 / v11; + *((float *)v8 + 1) = 1.0 / *(float *)v7; + if ( a2 & 0xFF000000 ) + v12 = *((int *)v7 + 1); + else + v12 = a2; + *((int *)v8 + 3) = 0; + *((int *)v8 + 2) = v12; + ++v6; + v7 += 16; + *((float *)v8 + 4) = 0.0; + *((float *)v8 + 5) = 0.0; + v8 += 32; + } + while ( v6 < a1->field_10 ); + } + v13 = a1->field_10; + pBillboardRenderListD3D[v5].pTexture = 0; + pBillboardRenderListD3D[v5].uNumVertices = v13; + LODWORD(pBillboardRenderListD3D[v5].flt_88) = v14; + } +} + + +//----- (004A4DE1) -------------------------------------------------------- +bool Render::LoadTexture(const char *pName, unsigned int bMipMaps, IDirectDrawSurface4 **pOutSurface, IDirect3DTexture2 **pOutTexture) +{ + HRESULT v12; // eax@14 + unsigned __int16 *v13; // ecx@19 + unsigned __int16 *v14; // eax@19 + DWORD v15; // edx@20 + HRESULT v16; // eax@23 + stru350 Dst; // [sp+Ch] [bp-F8h]@12 + + auto pHWLTexture = pD3DBitmaps.LoadTexture(pName, bMipMaps); + if ( pHWLTexture ) + { + bMipMaps = !strncmp(pName, "HDWTR", 5); + if ( !pRenderD3D->CreateTexture( + pHWLTexture->uWidth, + pHWLTexture->uHeight, + pOutSurface, + pOutTexture, + true, + bMipMaps, + uMinDeviceTextureDim) ) + Abortf("HiScreen16::LoadTexture - D3Drend->CreateTexture() failed: %x", 0); + //v10 = *pOutSurface; + //v11 = 0; + if ( bMipMaps ) + { + Dst._450DDE(); + //v20 = 0; + Dst._450DF1(&stru_4EFCBC, &stru_4EFCBC); + + IDirectDrawSurface4 *pNextSurf = *pOutSurface; + while ( 1 ) + { + DDSCAPS2 v19; + memset(&v19, 0, sizeof(DDSCAPS2)); + v19.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_MIPMAP; + + DDSURFACEDESC2 desc; + memset(&desc, 0, sizeof(DDSURFACEDESC2)); + desc.dwSize = sizeof(DDSURFACEDESC2); + + if ( LockSurface_DDraw4(pNextSurf, &desc, 0x21u) ) + { + Dst.sub_451007_scale_image_bicubic( + pHWLTexture->pPixels, + pHWLTexture->uWidth, + pHWLTexture->uHeight, + pHWLTexture->uWidth, + (unsigned short *)desc.lpSurface, + desc.dwWidth, + desc.dwHeight, + desc.lPitch >> 1, + 0, + 0); + ErrD3D(pNextSurf->Unlock(0)); + //bMipMaps = 0x4D86ACu; + } + if (FAILED(pNextSurf->GetAttachedSurface(&v19, &pNextSurf))) + break; + //v10 = (IDirectDrawSurface4 *)pName; + //v11 = 0; + } + //v20 = -1; + //nullsub_1(); + } + else + { + DDSCAPS2 v19; + memset(&v19, 0, sizeof(DDSCAPS2)); + v19.dwCaps = DDSCAPS_TEXTURE | DDSCAPS_MIPMAP; + + DDSURFACEDESC2 desc; + memset(&desc, 0, sizeof(DDSURFACEDESC2)); + desc.dwSize = sizeof(DDSURFACEDESC2); + + if ( LockSurface_DDraw4(*pOutSurface, &desc, 0x21u) ) + { + bMipMaps = 0; + v13 = pHWLTexture->pPixels; + v14 = (unsigned __int16 *)desc.lpSurface; + if ( desc.dwHeight ) + { + do + { + v15 = 0; + if ( desc.dwWidth ) + { + do + { + ++v15; + *v14 = *v13; + ++v14; + ++v13; + } + while ( v15 < desc.dwWidth ); + } + ++bMipMaps; + v14 += (desc.lPitch >> 1) - desc.dwWidth; + } + while ( bMipMaps < desc.dwHeight ); + } + ErrD3D((*pOutSurface)->Unlock(0)); + } + } + delete [] pHWLTexture->pPixels; + delete pHWLTexture; + return true; + } + return false; +} + +//----- (004A5048) -------------------------------------------------------- +HWLTexture *Render::MoveSpriteToDevice(Sprite *pSprite) +{ + Sprite *v2; // edi@1 + Render *v3; // ebx@1 + HWLTexture *result; // eax@1 + HWLTexture *v5; // esi@1 + unsigned int v6; // ST18_4@2 + RenderD3D *v7; // ecx@2 + Sprite *v8; // ebx@4 + unsigned __int16 *v9; // edx@5 + LPVOID v10; // eax@5 + signed int v11; // ebx@5 + signed int v12; // ecx@6 + signed int v13; // edi@7 + HRESULT v14; // eax@10 + DDSURFACEDESC2 Dst; // [sp+Ch] [bp-7Ch]@4 + + v2 = pSprite; + v3 = this; + result = pD3DSprites.LoadTexture(pSprite->pName, pSprite->uPaletteID); + v5 = result; + if ( result ) + { + v3->_gpu_memory_used += 2 * result->uWidth * result->uHeight; + v2->uAreaX = result->field_30; + v2->uAreaY = result->field_34; + v2->uBufferWidth = result->field_18; + v2->uBufferHeight = result->field_1C; + v2->uAreaWidth = result->field_20; + v2->uAreaHeight = result->field_24; + v6 = v3->uMinDeviceTextureDim; + v7 = v3->pRenderD3D; + if ( !v7->CreateTexture(result->uWidth, result->uHeight, &v2->pTextureSurface, &v2->pTexture, 1u, 0, v6) ) + Abortf("HiScreen16::LoadTexture - D3Drend->CreateTexture() failed: %x", 0); + //pSprite = v2->pTextureSurface; + //pSprite = (Sprite *)pSprite->pName; + //v8 = pSprite; + memset(&Dst, 0, 0x7Cu); + Dst.dwSize = 124; + if ( LockSurface_DDraw4((IDirectDrawSurface4 *)v2->pTextureSurface, &Dst, 0x21u) ) + { + v9 = v5->pPixels; + v10 = Dst.lpSurface; + v11 = 0; + if ( (signed int)v5->uHeight > 0 ) + { + v12 = (signed int)v5->uWidth >> 1; + do + { + v13 = 0; + if ( v12 > 0 ) + { + do + { + ++v13; + *(int *)v10 = *(int *)v9; + v9 += 2; + v10 = (char *)v10 + 4; + } + while ( v13 < (signed int)v5->uWidth >> 1 ); + } + v12 = (signed int)v5->uWidth >> 1; + ++v11; + v10 = (char *)v10 + 4 * ((Dst.lPitch >> 2) - v12); + } + while ( v11 < (signed int)v5->uHeight ); + } + ErrD3D(v2->pTextureSurface->Unlock(0)); + } + free(v5->pPixels); + free(v5); + result = (HWLTexture *)1; + } + return result; +} + +//----- (004A51CB) -------------------------------------------------------- +void Render::BeginScene() +{ + Render *v1; // esi@1 + unsigned int v2; // eax@1 + int v3; // eax@5 + unsigned __int16 **v4; // edi@6 + char *v5; // ebx@7 + DDSURFACEDESC2 Dst; // [sp+Ch] [bp-7Ch]@4 + + v1 = this; + v2 = this->uNumSceneBegins; + this->uNumSceneBegins = v2 + 1; + if ( !v2 ) + { + if ( this->pRenderD3D ) + { + if ( this->bColorKeySupported ) + { + memset(&Dst, 0, 0x7Cu); + Dst.dwSize = 124; + if ( LockSurface_DDraw4(v1->pColorKeySurface4, &Dst, 0x801u) ) + { + v1->pTargetSurface = (unsigned __int16 *)Dst.lpSurface; + v3 = Dst.lPitch >> 1; + v1->uTargetSurfacePitch = Dst.lPitch >> 1; +LABEL_10: + v1->field_18_locked_pitch = v3; + goto LABEL_11; + } + goto LABEL_8; + } + } + else + { + v4 = &this->pTargetSurface; + if ( !this->pTargetSurface ) + { + v5 = (char *)&this->uTargetSurfacePitch; + LockRenderSurface((void **)&this->pTargetSurface, &this->uTargetSurfacePitch); + if ( *v4 ) + { + v3 = *(int *)v5; + goto LABEL_10; + } +LABEL_8: + --v1->uNumSceneBegins; + return; + } + } +LABEL_11: + RestoreFrontBuffer(); + } +} + +//----- (004A527D) -------------------------------------------------------- +void Render::EndScene() +{ + unsigned int v1; // edx@1 + unsigned int v2; // edx@2 + HRESULT v3; // eax@5 + + v1 = this->uNumSceneBegins; + if ( v1 ) + { + v2 = v1 - 1; + this->uNumSceneBegins = v2; + if ( !v2 ) + { + if ( this->pRenderD3D ) + { + 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->field_18_locked_pitch = 0; + UnlockBackBuffer(); + } + } + } +} + + +//----- ( ) -------------------------------------------------------- +unsigned int Render::_4A52F1(unsigned int this_, float a3) +{ + unsigned int v3; // esi@1 + double v4; // st7@2 + double v5; // st7@6 + double v6; // st6@6 + unsigned int v7; // eax@6 + double v8; // st5@6 + double v9; // st4@6 + HRESULT v10; // eax@6 + HRESULT v11; // eax@6 + unsigned int result; // eax@6 + unsigned int v13; // eax@7 + unsigned __int16 *v14; // ecx@7 + int *v15; // eax@7 + unsigned int v16; // ecx@8 + __int16 v17; // ax@10 + int v18; // esi@10 + float v19; // edi@10 + void *v20; // esi@10 + int v21; // edx@10 + int v22; // ecx@11 + int v23; // edx@12 + __int16 v24; // ax@15 + int v25; // esi@15 + float v26; // edi@15 + char *v27; // esi@15 + int v28; // edx@15 + int v29; // ecx@16 + int v30; // edx@17 + int v31; // [sp-Ch] [bp-ACh]@11 + int v32; // [sp-Ch] [bp-ACh]@16 + const char *v33; // [sp+0h] [bp-A0h]@0 + int v34; // [sp+4h] [bp-9Ch]@0 + unsigned int v35; // [sp+8h] [bp-98h]@0 + RenderVertexD3D3 v36[4]; // [sp+Ch] [bp-94h]@6 + unsigned int v37; // [sp+8Ch] [bp-14h]@7 + int v38; // [sp+90h] [bp-10h]@7 + double v39; // [sp+94h] [bp-Ch]@6 + float v40; // [sp+9Ch] [bp-4h]@6 + + auto ecx0 = this; + v3 = 0; + if ( ecx0->pRenderD3D ) + { + v4 = a3; + if ( a3 <= 1.0 ) + { + if ( v4 < 0.0 ) + v4 = 0.0; + } + else + { + v4 = 1.0; + } + a3 = v4 * 255.0; + v39 = a3 + 6.7553994e15; + LODWORD(v40) = LODWORD(v39); + v5 = (double)(signed int)pViewport->uViewportX; + v36[0].pos.x = v5; + v6 = (double)(signed int)pViewport->uViewportY; + v7 = this_ | (LODWORD(v39) << 24); + this_ = pViewport->uViewportW + 1; + v36[0].specular = 0; + v36[0].pos.y = v6; + v36[0].diffuse = v7; + v36[1].diffuse = v7; + v36[0].pos.z = 0.0; + v36[2].diffuse = v7; + v36[3].diffuse = v7; + v36[0].rhw = 1.0; + v36[1].specular = 0; + v36[0].texcoord.x = 0.0; + v36[2].specular = 0; + v36[3].specular = 0; + v36[0].texcoord.y = 0.0; + v36[1].pos.x = v5; + v8 = (double)(pViewport->uViewportW + 1); + v36[1].pos.y = v8; + v36[1].pos.z = 0.0; + v36[1].rhw = 1.0; + v36[1].texcoord.x = 0.0; + v36[1].texcoord.y = 0.0; + v9 = (double)(signed int)pViewport->uViewportZ; + v36[2].pos.x = v9; + v36[2].pos.y = v8; + v36[2].pos.z = 0.0; + v36[2].rhw = 1.0; + v36[2].texcoord.x = 0.0; + v36[2].texcoord.y = 0.0; + v36[3].pos.x = v9; + v36[3].pos.y = v6; + v36[3].pos.z = 0.0; + v36[3].rhw = 1.0; + v36[3].texcoord.x = 0.0; + v36[3].texcoord.y = 0.0; + ErrD3D(pRenderD3D->pDevice->SetTexture(0, 0)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_FOGENABLE, 0)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ALPHABLENDENABLE, 1u)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ZWRITEENABLE, 0)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, 5u)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, 6u)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_DITHERENABLE, 0)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ZFUNC, 8u)); + ErrD3D(pRenderD3D->pDevice->DrawPrimitive( + D3DPT_TRIANGLEFAN, + D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_SPECULAR | D3DFVF_TEX1, + v36, + 4, + 28)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, 2)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, 1u)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ALPHABLENDENABLE, 0)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ZWRITEENABLE, 1u)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_DITHERENABLE, 1u)); + ErrD3D(pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ZFUNC, 2u)); + } + else + { + v40 = (1.0 - a3) * 65536.0; + v39 = v40 + 6.7553994e15; + LODWORD(a3) = LODWORD(v39); + v38 = (signed int)(pViewport->uViewportZ - pViewport->uViewportX) >> 1; + HIDWORD(v39) = pViewport->uViewportW - pViewport->uViewportY + 1; + v13 = pViewport->uViewportX + ecx0->uTargetSurfacePitch - pViewport->uViewportZ; + v14 = &ecx0->pTargetSurface[pViewport->uViewportX + pViewport->uViewportY * ecx0->uTargetSurfacePitch]; + v37 = 2 * v13; + LODWORD(v40) = (int)v14; + + int __i = 0; + v15 = dword_F1B430; + do + { + v16 = v3; + v3 += LODWORD(a3); + dword_F1B430[__i++] = v16 >> 16; + } + //while ( (signed int)v15 < (signed int)&Aureal3D_SplashScreen ); + while (__i < 32); + + if ( pRenderer->uTargetGBits == 6 ) + { + v17 = _42690D_colors_cvt(this_); + v18 = (65536 - LODWORD(a3)) * (v17 & 0x1F); + this_ = (((65536 - LODWORD(a3)) * (unsigned __int16)(v17 & 0xF800) & 0xF800FFFF | v18 & 0x1F0000 | (65536 - LODWORD(a3)) * (v17 & 0x7E0) & 0x7E00000u) >> 16 << 16) | (((65536 - LODWORD(a3)) * (unsigned __int16)(v17 & 0xF800) & 0xF800FFFF | v18 & 0x1F0000 | (65536 - LODWORD(a3)) * (v17 & 0x7E0) & 0x7E00000u) >> 16); + v19 = v40; + v20 = off_4EFDB0; + v21 = HIDWORD(v39); + do + { + v22 = v38; + v31 = v21; + do + { + v23 = (*(int *)((char *)v20 + + ((((unsigned __int16)(*(short *)((char *)v20 + ((*(unsigned int *)LODWORD(v19) & 0xF800u) >> 9)) << 11) | *(unsigned int *)LODWORD(v19) & 0x7FF) & 0x7C0u) >> 4)) << 6) | (*(int *)((char *)v20 + ((((*(int *)((char *)v20 + ((*(unsigned int *)LODWORD(v19) & 0xF800u) >> 9)) << 11) | (*(int *)((char *)v20 + ((*(unsigned int *)LODWORD(v19) & 0xF8000000u) >> 25)) << 27) | *(unsigned int *)LODWORD(v19) & 0x7FF07FF) & 0x7C00000u) >> 20)) << 22) | ((*(int *)((char *)v20 + ((*(unsigned int *)LODWORD(v19) & 0xF800u) >> 9)) << 11) | (*(int *)((char *)v20 + ((*(unsigned int *)LODWORD(v19) & 0xF8000000u) >> 25)) << 27) | *(unsigned int *)LODWORD(v19) & 0x7FF07FF) & 0xF81FF81F; + result = this_ + + (*((int *)v20 + + (((unsigned __int8)(*((char *)v20 + + ((((unsigned __int16)(*(short *)((char *)v20 + + ((*(unsigned int *)LODWORD(v19) & 0xF800u) >> 9)) << 11) | *(unsigned int *)LODWORD(v19) & 0x7FF) & 0x7C0u) >> 4)) << 6) | *(unsigned int *)LODWORD(v19) & 0x1F) & 0x1F)) | (*(int *)((char *)v20 + ((v23 & 0x1F0000u) >> 14)) << 16) | ((*(int *)((char *)v20 + ((((unsigned __int16)(*(short *)((char *)v20 + ((*(unsigned int *)LODWORD(v19) & 0xF800u) >> 9)) << 11) | *(unsigned int *)LODWORD(v19) & 0x7FF) & 0x7C0u) >> 4)) << 6) | (*(int *)((char *)v20 + ((((*(int *)((char *)v20 + ((*(unsigned int *)LODWORD(v19) & 0xF800u) >> 9)) << 11) | (*(int *)((char *)v20 + ((*(unsigned int *)LODWORD(v19) & 0xF8000000u) >> 25)) << 27) | *(unsigned int *)LODWORD(v19) & 0x7FF07FF) & 0x7C00000u) >> 20)) << 22) | ((*(int *)((char *)v20 + ((*(unsigned int *)LODWORD(v19) & 0xF800u) >> 9)) << 11) | (*(int *)((char *)v20 + ((*(unsigned int *)LODWORD(v19) & 0xF8000000u) >> 25)) << 27) | *(unsigned int *)LODWORD(v19) & 0x7FF07FF) & 0xF81FF81F) & 0xFFE0FFE0); + *(unsigned int *)LODWORD(v19) = result; + LODWORD(v19) += 4; + --v22; + } + while ( v22 ); + LODWORD(v19) += v37; + v21 = v31 - 1; + } + while ( v31 != 1 ); + } + else + { + v24 = _4268E3_smthn_to_a1r5g5b5(this_); + v25 = (65536 - LODWORD(a3)) * (v24 & 0x1F); + this_ = (((65536 - LODWORD(a3)) * (v24 & 0x7C00) & 0x7C000000 | v25 & 0x1F0000 | (65536 - LODWORD(a3)) + * (v24 & 0x3E0) & 0x3E00000u) >> 16 << 16) | (((65536 - LODWORD(a3)) * (v24 & 0x7C00) & 0x7C000000 | v25 & 0x1F0000 | (65536 - LODWORD(a3)) * (v24 & 0x3E0) & 0x3E00000u) >> 16); + v26 = v40; + v27 = (char *)off_4EFDB0; + v28 = HIDWORD(v39); + do + { + v29 = v38; + v32 = v28; + do + { + v30 = 32 + * *(int *)&v27[(((unsigned __int16)(*(short *)&v27[(*(unsigned int *)LODWORD(v26) & 0x7C00u) >> 8] << 10) | *(unsigned int *)LODWORD(v26) & 0x3FF) & 0x3E0u) >> 3] | (*(int *)&v27[(((*(int *)&v27[(*(unsigned int *)LODWORD(v26) & 0x7C00u) >> 8] << 10) | (*(int *)&v27[(*(unsigned int *)LODWORD(v26) & 0x7C000000u) >> 24] << 26) | *(unsigned int *)LODWORD(v26) & 0x3FF03FF) & 0x3E00000u) >> 19] << 21) | ((*(int *)&v27[(*(unsigned int *)LODWORD(v26) & 0x7C00u) >> 8] << 10) | (*(int *)&v27[(*(unsigned int *)LODWORD(v26) & 0x7C000000u) >> 24] << 26) | *(unsigned int *)LODWORD(v26) & 0x3FF03FF) & 0x7C1F7C1F; + result = this_ + + (*(int *)&v27[4 + * (((unsigned __int8)(32 + * v27[(((unsigned __int16)(*(short *)&v27[(*(unsigned int *)LODWORD(v26) & 0x7C00u) >> 8] << 10) | *(unsigned int *)LODWORD(v26) & 0x3FF) & 0x3E0u) >> 3]) | *(unsigned int *)LODWORD(v26) & 0x1F) & 0x1F)] | (*(int *)&v27[(v30 & 0x1F0000u) >> 14] << 16) | (32 * *(int *)&v27[(((unsigned __int16)(*(short *)&v27[(*(unsigned int *)LODWORD(v26) & 0x7C00u) >> 8] << 10) | *(unsigned int *)LODWORD(v26) & 0x3FF) & 0x3E0u) >> 3] | (*(int *)&v27[(((*(int *)&v27[(*(unsigned int *)LODWORD(v26) & 0x7C00u) >> 8] << 10) | (*(int *)&v27[(*(unsigned int *)LODWORD(v26) & 0x7C000000u) >> 24] << 26) | *(unsigned int *)LODWORD(v26) & 0x3FF03FF) & 0x3E00000u) >> 19] << 21) | ((*(int *)&v27[(*(unsigned int *)LODWORD(v26) & 0x7C00u) >> 8] << 10) | (*(int *)&v27[(*(unsigned int *)LODWORD(v26) & 0x7C000000u) >> 24] << 26) | *(unsigned int *)LODWORD(v26) & 0x3FF03FF) & 0x7C1F7C1F) & 0xFFE0FFE0); + *(unsigned int *)LODWORD(v26) = result; + LODWORD(v26) += 4; + --v29; + } + while ( v29 ); + LODWORD(v26) += v37; + v28 = v32 - 1; + } + while ( v32 != 1 ); + } + } + return result; +} + + + +//----- (004A5B81) -------------------------------------------------------- +void Render::Clip(unsigned int uX, unsigned int uY, unsigned int uZ, unsigned int uW) +{ + this->bClip = 1; + this->uClipY = uY; + this->uClipX = uX; + this->uClipW = uW; + this->uClipZ = uZ; +} + + +//----- (004A5BB6) -------------------------------------------------------- +void Render::ResetClip() +{ + this->uClipY = 0; + this->uClipX = 0; + this->bClip = 1; + this->uClipW = 480; + this->uClipZ = 640; +} + + +//----- (004A5BE3) -------------------------------------------------------- +void Render::DrawTextureRGB(unsigned int uOutX, unsigned int uOutY, RGBTexture *a4) +{ + int v4; // edi@3 + unsigned __int16 *v5; // edx@3 + unsigned __int16 *v6; // esi@3 + unsigned int v7; // ebx@4 + unsigned int v8; // eax@5 + unsigned int v9; // ebx@5 + unsigned int v10; // eax@6 + unsigned int v11; // eax@7 + unsigned int v12; // ebx@8 + unsigned int v13; // eax@10 + unsigned int v14; // edi@11 + unsigned int v15; // eax@14 + unsigned int v16; // ebx@17 + int v17; // eax@23 + char v18; // zf@25 + int v19; // [sp+10h] [bp-8h]@3 + int v20; // [sp+14h] [bp-4h]@3 + unsigned int uOutXa; // [sp+20h] [bp+8h]@16 + int uOutXb; // [sp+20h] [bp+8h]@21 + int v23; // [sp+28h] [bp+10h]@3 + + if ( this->uNumSceneBegins && a4 ) + { + v4 = a4->uWidth; + v5 = &this->pTargetSurface[uOutX + uOutY * this->uTargetSurfacePitch]; + v6 = a4->pPixels; + v20 = v4; + v23 = a4->uHeight; + v19 = v4; + if ( this->bClip ) + { + v7 = this->uClipX; + if ( (signed int)uOutX < (signed int)v7 ) + { + v8 = v7 - uOutX; + v9 = uOutX - v7; + v8 *= 2; + v4 += v9; + v6 = (unsigned __int16 *)((char *)v6 + v8); + v20 += v9; + v5 = (unsigned __int16 *)((char *)v5 + v8); + } + v10 = this->uClipY; + if ( (signed int)uOutY < (signed int)v10 ) + { + v11 = v10 - uOutY; + v6 += v19 * v11; + v23 += uOutY - this->uClipY; + v4 = v20; + v5 += this->uTargetSurfacePitch * v11; + } + v12 = this->uClipX; + if ( (signed int)v12 < (signed int)uOutX ) + v12 = uOutX; + v13 = this->uClipZ; + if ( (signed int)(v4 + v12) > (signed int)v13 ) + { + v14 = this->uClipX; + if ( (signed int)v14 < (signed int)uOutX ) + v14 = uOutX; + v4 = v13 - v14; + } + v15 = this->uClipY; + if ( (signed int)v15 < (signed int)uOutY ) + v15 = uOutY; + uOutXa = this->uClipW; + if ( (signed int)(v15 + v23) > (signed int)uOutXa ) + { + v16 = this->uClipY; + if ( (signed int)v16 < (signed int)uOutY ) + v16 = uOutY; + v23 = uOutXa - v16; + } + } + if ( v23 > 0 ) + { + uOutXb = v23; + do + { + if ( v4 > 0 ) + { + v17 = v4; + do + { + *v5 = *v6; + ++v5; + ++v6; + --v17; + } + while ( v17 ); + } + v6 += v19 - v4; + v18 = uOutXb-- == 1; + v5 += this->uTargetSurfacePitch - v4; + } + while ( !v18 ); + } + } +} + + +//----- (004A5D33) -------------------------------------------------------- +void Render::_4A5D33(unsigned int pX, unsigned int pY, int a4, int a5, RGBTexture *pTexture) +{ + Render *v6; // esi@1 + unsigned __int16 *v7; // ebx@3 + int v8; // ecx@3 + int v9; // edx@3 + int v10; // ecx@3 + int v11; // edi@3 + signed int v12; // eax@4 + unsigned int v13; // eax@5 + signed int v14; // eax@6 + unsigned int v15; // eax@7 + unsigned int v16; // edx@8 + int v17; // eax@10 + unsigned int v18; // ecx@11 + unsigned int v19; // ecx@14 + int v20; // eax@16 + unsigned int v21; // ecx@17 + int v22; // eax@21 + int v23; // edi@23 + int v24; // [sp+Ch] [bp-4h]@3 + int a2a; // [sp+18h] [bp+8h]@21 + unsigned int teal; // [sp+1Ch] [bp+Ch]@20 + int a4a; // [sp+20h] [bp+10h]@3 + int a4b; // [sp+20h] [bp+10h]@21 + unsigned __int16 *pTexturea; // [sp+28h] [bp+18h]@3 + + v6 = this; + if ( this->uNumSceneBegins && pTexture ) + { + v7 = &this->pTargetSurface[pX + pY * this->uTargetSurfacePitch]; + v8 = pTexture->uWidth; + v24 = pTexture->uWidth; + v9 = a4 + a5 * v8; + v10 = v8 - a4; + a4a = v10; + v11 = pTexture->uHeight - a5; + pTexturea = &pTexture->pPixels[v9]; + if ( v6->bClip ) + { + v12 = v6->uClipX; + if ( (signed int)pX < v12 ) + { + v13 = 2 * (v12 - pX); + pTexturea = (unsigned __int16 *)((char *)pTexturea + v13); + v10 += pX - v6->uClipX; + v7 = (unsigned __int16 *)((char *)v7 + v13); + a4a = v10; + } + v14 = v6->uClipY; + if ( (signed int)pY < v14 ) + { + v15 = v14 - pY; + pTexturea += v24 * v15; + v11 += pY - v6->uClipY; + v10 = a4a; + v7 += v6->uTargetSurfacePitch * v15; + } + v16 = v6->uClipX; + if ( (signed int)v16 < (signed int)pX ) + v16 = pX; + v17 = v6->uClipZ; + if ( (signed int)(v10 + v16) > v17 ) + { + v18 = v6->uClipX; + if ( (signed int)v18 < (signed int)pX ) + v18 = pX; + a4a = v17 - v18; + } + v19 = v6->uClipY; + if ( (signed int)v19 < (signed int)pY ) + v19 = pY; + v20 = v6->uClipW; + if ( (signed int)(v11 + v19) > v20 ) + { + v21 = v6->uClipY; + if ( (signed int)v21 < (signed int)pY ) + v21 = pY; + v11 = v20 - v21; + } + } + teal = GenerateColorAsCloseAsPossibleToR8G8B8InTargetFormat(0, 0xFFu, 0xFFu); + if ( v11 > 0 ) + { + v22 = a4a; + a2a = v11; + a4b = 2 * (v24 - a4a); + do + { + if ( v22 > 0 ) + { + v23 = v22; + do + { + if ( *pTexturea != teal ) + *v7 = *pTexturea; + ++pTexturea; + ++v7; + --v23; + } + while ( v23 ); + } + v7 += v6->uTargetSurfacePitch - v22; + pTexturea = (unsigned __int16 *)((char *)pTexturea + a4b); + --a2a; + } + while ( a2a ); + } + } +} + + + +//----- (004A6E7E) -------------------------------------------------------- +void Render::_4A6E7E(unsigned int a2, unsigned int a3, Texture *a4) +{ + 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 v10; // edx@8 + unsigned int v11; // ebx@9 + unsigned int v12; // esi@11 + unsigned int v13; // edx@12 + unsigned int v14; // ebx@15 + unsigned int v15; // esi@17 + unsigned int v16; // edi@18 + char v17; // zf@29 + int v18; // [sp+14h] [bp-Ch]@4 + int v19; // [sp+18h] [bp-8h]@4 + unsigned __int8 *v20; // [sp+1Ch] [bp-4h]@4 + int v21; // [sp+28h] [bp+8h]@25 + int v22; // [sp+28h] [bp+8h]@34 + 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]; + v20 = a4->pLevelOfDetail0; + v5 = a4->uTextureWidth; + v6 = a4->uTextureHeight; + v19 = a4->uTextureWidth; + v18 = a4->uTextureWidth; + if ( this->bClip ) + { + v7 = this->uClipX; + if ( (signed int)a2 < (signed int)v7 ) + { + v8 = v7 - a2; + v20 += v8; + v19 += a2 - this->uClipX; + v4 += v8; + } + 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; + } + v11 = this->uClipX; + v5 = v19; + if ( (signed int)v11 < (signed int)a2 ) + v11 = a2; + v12 = this->uClipZ; + if ( (signed int)(v19 + v11) > (signed int)v12 ) + { + v13 = this->uClipX; + if ( (signed int)v13 < (signed int)a2 ) + v13 = a2; + v5 = v12 - v13; + } + v14 = this->uClipY; + if ( (signed int)v14 < (signed int)a3 ) + v14 = a3; + v15 = this->uClipW; + if ( (signed int)(v6 + v14) > (signed int)v15 ) + { + v16 = this->uClipY; + if ( (signed int)v16 < (signed int)a3 ) + v16 = a3; + v6 = v15 - v16; + } + } + if ( pRenderer->uTargetGBits == 5 ) + { + if ( (signed int)v6 > 0 ) + { + v23 = v6; + do + { + if ( v5 > 0 ) + { + v21 = v5; + do + { + if ( *v20 ) + *v4 = ((unsigned int)a4->pPalette16[*v20] >> 1) & 0x3DEF; + ++v4; + ++v20; + --v21; + } + while ( v21 ); + } + v20 += v18 - v5; + v17 = v23-- == 1; + v4 += this->uTargetSurfacePitch - v5; + } + while ( !v17 ); + } + } + else + { + if ( (signed int)v6 > 0 ) + { + v24 = v6; + do + { + if ( v5 > 0 ) + { + v22 = v5; + do + { + if ( *v20 ) + *v4 = ((unsigned int)a4->pPalette16[*v20] >> 1) & 0x7BEF; + ++v4; + ++v20; + --v22; + } + while ( v22 ); + } + v20 += v18 - v5; + 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) +{ + 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 ( pTarget ) + { + pBitmapa = &pBitmap[pBitmapXY->x + uBitmapPitch * pBitmapXY->y]; + pTargeta = &pTarget[a7->x + uTargetPitch * a7->y]; + v8 = a7->z - a7->x; + result = a7->w - a7->y; + if ( result > 0 ) + { + v9 = pBitmapa; + v10 = pTargeta; + v11 = a7->w - a7->y; + do + { + if ( v8 > 0 ) + { + result = v8; + do + { + *v9 = *v10; + ++v9; + ++v10; + --result; + } + while ( result ); + } + v9 += uBitmapPitch - 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) +{ + if (!uNumSceneBegins) + return; + + unsigned __int32 twoColors = (uColor16 << 16) | uColor16; + for (uint y = 0; y < uHeight; ++y) + { + auto pDst = &pTargetSurface[uX + (y + uY) * uTargetSurfacePitch]; + + memset32(pDst, twoColors, uWidth / 2); + if (uWidth & 1) + pDst[uWidth - 1] = 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 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 __int16 v22; // dx@24 + char v23; // zf@28 + unsigned __int8 *v24; // [sp+Ch] [bp-4h]@2 + unsigned int uOutXa; // [sp+18h] [bp+8h]@20 + + if ( this->uNumSceneBegins ) + { + v9 = uCharWidth; + v10 = uCharHeight; + v11 = &this->pTargetSurface[uOutX + uOutY * this->uTargetSurfacePitch]; + v24 = pFontPixels; + if ( this->bClip ) + { + v12 = this->uClipX; + if ( uOutX < (signed int)v12 ) + { + v24 = &pFontPixels[v12 - uOutX]; + v11 += v12 - uOutX; + 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; + } + v15 = this->uClipX; + if ( v15 < uOutX ) + v15 = uOutX; + v16 = this->uClipZ; + if ( (signed int)(v9 + v15) > (signed int)v16 ) + { + v17 = this->uClipX; + if ( v17 < uOutX ) + v17 = uOutX; + v9 = v16 - v17; + } + v18 = this->uClipY; + if ( v18 < uOutY ) + v18 = uOutY; + v19 = this->uClipW; + if ( (signed int)(v10 + v18) > (signed int)v19 ) + { + v20 = this->uClipY; + if ( v20 < uOutY ) + v20 = uOutY; + v10 = v19 - v20; + } + } + if ( (signed int)v10 > 0 ) + { + uOutXa = v10; + do + { + if ( (signed int)v9 > 0 ) + { + v21 = v9; + do + { + if ( *v24 ) + { + v22 = uShadowColor; + if ( *v24 != 1 ) + v22 = uFaceColor; + *v11 = v22; + } + ++v11; + ++v24; + --v21; + } + while ( v21 ); + } + v24 += uCharWidth - v9; + v23 = uOutXa-- == 1; + v11 += this->uTargetSurfacePitch - v9; + } + while ( !v23 ); + } + } +} + + + +//----- (004A6A68) -------------------------------------------------------- +void Render::_4A6A68(unsigned int a2, unsigned int a3, Texture *a4, __int16 height) +{ + Render *v5; // ebx@1 + unsigned __int16 v6; // ax@1 + + v5 = this; + + Texture tex; // [sp+Ch] [bp-48h]@1 + //Texture::Texture(&tex); + + v6 = a4->uTextureHeight - height; + memcpy(&tex, a4, sizeof(tex)); + tex.uTextureHeight = v6; + if ( (signed __int16)v6 > 0 ) + DrawTextureIndexed(a2, a3, &tex); +} + + + +//----- (004A6AB1) -------------------------------------------------------- +void Render::DrawTextPalette(int x, int y, int a4, 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 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 v16; // edx@9 + signed int v17; // edi@10 + signed int v18; // ebx@13 + unsigned int v19; // edx@15 + signed int v20; // esi@16 + int v21; // ebx@22 + char v22; // zf@28 + int v23; // ebx@31 + unsigned __int16 v24; // si@35 + int v25; // [sp+Ch] [bp-4h]@2 + int v26; // [sp+1Ch] [bp+Ch]@24 + int v27; // [sp+1Ch] [bp+Ch]@33 + unsigned int v28; // [sp+20h] [bp+10h]@30 + unsigned int v29; // [sp+24h] [bp+14h]@22 + unsigned int v30; // [sp+24h] [bp+14h]@31 + + auto a2 = x; + auto a3 = y; + auto a6 = uFontHeight; + if ( this->uNumSceneBegins ) + { + v8 = a5; + v9 = a6; + v10 = &pTargetSurface[x + y * uTargetSurfacePitch]; + v11 = (unsigned char *)a4; + v25 = a4; + if ( this->bClip ) + { + v12 = this->uClipX; + if ( a2 < (signed int)v12 ) + { + v25 = v12 - a2 + a4; + v10 += v12 - a2; + v8 = a5 + a2 - v12; + } + v13 = this->uClipY; + if ( a3 < v13 ) + { + v14 = v13 - a3; + v25 += a5 * v14; + v9 = a6 + a3 - this->uClipY; + v10 += this->uTargetSurfacePitch * v14; + } + v15 = this->uClipX; + if ( v15 < a2 ) + v15 = a2; + v16 = this->uClipZ; + if ( v8 + v15 > (signed int)v16 ) + { + v17 = this->uClipX; + if ( v17 < a2 ) + v17 = a2; + v8 = v16 - v17; + } + v18 = this->uClipY; + if ( v18 < a3 ) + v18 = a3; + v19 = this->uClipW; + if ( (signed int)(v9 + v18) > (signed int)v19 ) + { + v20 = this->uClipY; + if ( v20 < a3 ) + v20 = a3; + v9 = v19 - v20; + } + v11 = (unsigned char *)v25; + } + if ( a8 ) + { + v28 = pRenderer->uTargetGMask | pRenderer->uTargetBMask; + if ( (signed int)v9 > 0 ) + { + v23 = a5; + v30 = v9; + do + { + if ( v8 > 0 ) + { + v27 = v8; + do + { + if ( *v11 ) + v24 = pPalette[*v11]; + else + v24 = v28; + *v10 = v24; + ++v10; + ++v11; + --v27; + } + while ( v27 ); + } + v11 += v23 - v8; + v22 = v30-- == 1; + v10 += this->uTargetSurfacePitch - v8; + } + while ( !v22 ); + } + } + else + { + if ( (signed int)v9 > 0 ) + { + v21 = a5; + v29 = v9; + do + { + if ( v8 > 0 ) + { + v26 = v8; + do + { + if ( *v11 ) + *v10 = pPalette[*v11]; + ++v10; + ++v11; + --v26; + } + while ( v26 ); + } + 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 + 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; + 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::_4A6776(unsigned int a2, unsigned int a3, Texture *a4) +{ + 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 + 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 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 a2a; // [sp+28h] [bp+8h]@24 + unsigned int a3a; // [sp+2Ch] [bp+Ch]@22 + unsigned int a4a; // [sp+30h] [bp+10h]@11 + + if ( this->uNumSceneBegins ) + { + v4 = a4; + if ( a4 ) + { + if ( a4->pPalette16 ) + { + v5 = a4->uTextureHeight; + v6 = &this->pTargetSurface[a2 + a3 * this->uTargetSurfacePitch]; + v19 = a4->pLevelOfDetail0; + v20 = a4->uTextureWidth; + v18 = a4->uTextureWidth; + if ( this->bClip ) + { + v7 = this->uClipX; + if ( (signed int)a2 < (signed int)v7 ) + { + v8 = v7 - a2; + v19 += v8; + v20 += a2 - this->uClipX; + v6 += v8; + } + v9 = this->uClipY; + v5 = a4->uTextureHeight; + if ( (signed int)a3 < (signed int)v9 ) + { + v10 = v9 - a3; + v19 += v18 * v10; + v5 = a3 - this->uClipY + a4->uTextureHeight; + v4 = a4; + v6 += this->uTargetSurfacePitch * v10; + } + v11 = this->uClipX; + if ( (signed int)v11 < (signed int)a2 ) + v11 = a2; + a4a = this->uClipZ; + if ( (signed int)(v11 + v20) > (signed int)a4a ) + { + v12 = this->uClipX; + if ( (signed int)v12 < (signed int)a2 ) + v12 = a2; + v20 = a4a - v12; + } + v13 = this->uClipY; + if ( (signed int)v13 < (signed int)a3 ) + v13 = a3; + v14 = this->uClipW; + if ( (signed int)(v5 + v13) > (signed int)v14 ) + { + v15 = this->uClipY; + if ( (signed int)v15 < (signed int)a3 ) + v15 = a3; + v5 = v14 - v15; + } + } + if ( (signed int)v5 > 0 ) + { + a3a = v5; + v16 = v19; + do + { + if ( v20 > 0 ) + { + a2a = v20; + do + { + if ( *v16 ) + *v6 = this->uTargetRMask & v4->pPalette16[*v16]; + ++v6; + ++v16; + --a2a; + } + while ( a2a ); + } + v16 += v18 - v20; + v17 = a3a-- == 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 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 v14; // edx@11 + unsigned int v15; // eax@13 + unsigned int v16; // edx@14 + unsigned int v17; // edx@17 + unsigned int v18; // eax@19 + unsigned int v19; // edx@20 + int v20; // eax@27 + int v21; // edx@29 + int v22; // [sp+Ch] [bp-Ch]@6 + int v23; // [sp+Ch] [bp-Ch]@24 + unsigned __int8 *v24; // [sp+14h] [bp-4h]@6 + int xa; // [sp+20h] [bp+8h]@26 + 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]; + v24 = a4->pLevelOfDetail0; + v27 = a4->uTextureWidth; + v9 = a4->uTextureHeight; + v22 = a4->uTextureWidth; + if ( this->bClip ) + { + v10 = this->uClipX; + if ( (signed int)x < (signed int)v10 ) + { + v11 = v10 - x; + v24 += v11; + v27 += x - this->uClipX; + v8 += v11; + } + 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; + } + v14 = this->uClipX; + if ( (signed int)v14 < (signed int)x ) + v14 = x; + v15 = this->uClipZ; + if ( (signed int)(v27 + v14) > (signed int)v15 ) + { + v16 = this->uClipX; + if ( (signed int)v16 < (signed int)x ) + v16 = x; + v27 = v15 - v16; + } + v17 = this->uClipY; + if ( (signed int)v17 < (signed int)y ) + v17 = y; + v18 = this->uClipW; + if ( (signed int)(v9 + v17) > (signed int)v18 ) + { + v19 = this->uClipY; + if ( (signed int)v19 < (signed int)y ) + v19 = y; + v9 = v18 - v19; + } + } + if ( (signed int)v9 > 0 ) + { + ya = v9; + v23 = v22 - v27; + do + { + if ( v27 > 0 ) + { + xa = v27; + do + { + 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]; + } + ++v8; + ++v24; + --xa; + } + while ( xa ); + } + v8 += this->uTargetSurfacePitch - v27; + v24 += v23; + --ya; + } + while ( ya ); + } + } +} + + +//----- (004A63E6) -------------------------------------------------------- +void Render::_4A63E6(unsigned int a2, unsigned int a3, Texture *a4, Texture *a5, int a6, int a7, int a8) +{ + Texture *v8; // eax@2 + Texture *v9; // ebx@4 + 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 + unsigned int v16; // edx@14 + unsigned int v17; // edx@17 + unsigned int v18; // eax@19 + unsigned int v19; // edx@20 + int v20; // eax@27 + int v21; // edx@29 + int v22; // [sp+Ch] [bp-Ch]@6 + int v23; // [sp+Ch] [bp-Ch]@24 + int v24; // [sp+10h] [bp-8h]@6 + int v25; // [sp+14h] [bp-4h]@6 + int i; // [sp+20h] [bp+8h]@25 + int v27; // [sp+24h] [bp+Ch]@23 + unsigned __int8 *v28; // [sp+28h] [bp+10h]@6 + + if ( this->uNumSceneBegins ) + { + v8 = a4; + if ( a4 ) + { + if ( a4->pPalette16 ) + { + v9 = a5; + if ( a5 ) + { + if ( a5->pPalette16 ) + { + v10 = &this->pTargetSurface[a2 + a3 * this->uTargetSurfacePitch]; + v28 = a4->pLevelOfDetail0; + v25 = v8->uTextureWidth; + v24 = v8->uTextureHeight; + v22 = v8->uTextureWidth; + if ( this->bClip ) + { + v11 = this->uClipX; + if ( (signed int)a2 < (signed int)v11 ) + { + v28 += v11 - a2; + v25 += a2 - v11; + v9 = a5; + v10 += v11 - a2; + } + 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; + } + v14 = this->uClipX; + if ( (signed int)v14 < (signed int)a2 ) + v14 = a2; + v15 = this->uClipZ; + if ( (signed int)(v25 + v14) > (signed int)v15 ) + { + v16 = this->uClipX; + if ( (signed int)v16 < (signed int)a2 ) + v16 = a2; + v25 = v15 - v16; + } + v17 = this->uClipY; + if ( (signed int)v17 < (signed int)a3 ) + v17 = a3; + v18 = this->uClipW; + if ( (signed int)(v24 + v17) > (signed int)v18 ) + { + v19 = this->uClipY; + if ( (signed int)v19 < (signed int)a3 ) + v19 = a3; + v24 = v18 - v19; + } + } + v27 = 0; + if ( v24 > 0 ) + { + v23 = v22 - v25; + do + { + for ( i = 0; i < v25; ++v28 ) + { + if ( *v28 ) + { + v20 = *(&v9->pLevelOfDetail0[i & v9->uWidthMinus1] + v9->uTextureWidth * (v27 & v9->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]; + } + } + } + ++i; + ++v10; + } + ++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 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 v15; // esi@18 + unsigned __int8 *v16; // ebx@22 + char uFlag; // zf@28 + int v18; // [sp+10h] [bp-10h]@4 + unsigned __int8 *v19; // [sp+18h] [bp-8h]@4 + int uWidth; // [sp+1Ch] [bp-4h]@4 + int uXa; // [sp+28h] [bp+8h]@24 + unsigned int uYa; // [sp+2Ch] [bp+Ch]@22 + unsigned int pTexturea; // [sp+30h] [bp+10h]@11 + + if ( this->uNumSceneBegins ) + { + pCurrentTexture = pTexture; + if ( pTexture ) + { + if ( pTexture->pPalette16 ) + { + uHeight = pTexture->uTextureHeight; + v6 = &this->pTargetSurface[uX + uY * this->uTargetSurfacePitch]; + v19 = pTexture->pLevelOfDetail0; + uWidth = pTexture->uTextureWidth; + v18 = pTexture->uTextureWidth; + if ( this->bClip ) + { + v7 = this->uClipX; + if ( (signed int)uX < (signed int)v7 ) + { + v8 = v7 - uX; + v19 += v8; + uWidth += uX - this->uClipX; + v6 += v8; + } + 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; + } + v11 = this->uClipX; + if ( (signed int)v11 < (signed int)uX ) + v11 = uX; + pTexturea = this->uClipZ; + if ( (signed int)(v11 + uWidth) > (signed int)pTexturea ) + { + v12 = this->uClipX; + if ( (signed int)v12 < (signed int)uX ) + v12 = uX; + uWidth = pTexturea - v12; + } + v13 = this->uClipY; + if ( (signed int)v13 < (signed int)uY ) + v13 = uY; + v14 = this->uClipW; + if ( (signed int)(uHeight + v13) > (signed int)v14 ) + { + v15 = this->uClipY; + if ( (signed int)v15 < (signed int)uY ) + v15 = uY; + uHeight = v14 - v15; + } + } + if ( (signed int)uHeight > 0 ) + { + uYa = uHeight; + v16 = v19; + do + { + if ( uWidth > 0 ) + { + uXa = uWidth; + do + { + if ( *v16 ) + *v6 = pCurrentTexture->pPalette16[*v16]; + ++v6; + ++v16; + } + while ( uXa-- !=1 ); + } + v16 += v18 - uWidth; + uFlag = uYa-- == 1; + v6 += this->uTargetSurfacePitch - uWidth; + } + while ( !uFlag ); + } + } + } + } +} + + +//----- (004A612A) -------------------------------------------------------- +void Render::_4A612A(signed int uOutX, unsigned int uOutY, Texture *pTexture, int zVal) +{ + Texture *v5; // eax@2 + unsigned int v6; // edx@3 + int v7; // ebx@3 + int v8; // edi@3 + signed int v9; // eax@4 + int v10; // eax@5 + unsigned int v11; // esi@6 + signed int v12; // esi@8 + unsigned int v13; // eax@10 + signed int v14; // esi@11 + unsigned int v15; // esi@14 + unsigned int v16; // eax@16 + unsigned int v17; // ecx@17 + int v18; // edx@23 + int v19; // [sp+Ch] [bp-Ch]@3 + int v20; // [sp+10h] [bp-8h]@3 + int uOutXa; // [sp+20h] [bp+8h]@21 + unsigned __int8 *uOutYa; // [sp+24h] [bp+Ch]@3 + int *pZBuffer; // [sp+28h] [bp+10h]@3 + + if ( this->uNumSceneBegins ) + { + v5 = pTexture; + if ( pTexture ) + { + v6 = uOutY; + v7 = pTexture->uTextureHeight; + pZBuffer = &this->pActiveZBuffer[uOutX + 640 * uOutY]; + uOutYa = v5->pLevelOfDetail0; + v8 = v5->uTextureWidth; + v20 = v5->uTextureWidth; + v19 = v5->uTextureWidth; + if ( this->bClip ) + { + v9 = this->uClipX; + if ( uOutX < v9 ) + { + v10 = v9 - uOutX; + uOutYa += v10; + v8 += uOutX - this->uClipX; + v20 = v8; + pZBuffer += v10; + } + v11 = this->uClipY; + if ( (signed int)v6 < (signed int)v11 ) + { + uOutYa += v19 * (v11 - v6); + v7 += v6 - v11; + pZBuffer += 640 * (v11 - v6); + v8 = v20; + } + v12 = this->uClipX; + if ( v12 < uOutX ) + v12 = uOutX; + v13 = this->uClipZ; + if ( v8 + v12 > (signed int)v13 ) + { + v14 = this->uClipX; + if ( v14 < uOutX ) + v14 = uOutX; + v8 = v13 - v14; + } + v15 = this->uClipY; + if ( (signed int)v15 < (signed int)v6 ) + v15 = v6; + v16 = this->uClipW; + if ( (signed int)(v7 + v15) > (signed int)v16 ) + { + v17 = this->uClipY; + if ( (signed int)v17 >= (signed int)v6 ) + v6 = v17; + v7 = v16 - v6; + } + } + if ( v7 > 0 ) + { + uOutXa = v7; + do + { + if ( v8 > 0 ) + { + v18 = v8; + do + { + if ( *uOutYa ) + *pZBuffer = zVal; + ++pZBuffer; + ++uOutYa; + --v18; + } + while ( v18 ); + } + pZBuffer += 640 - v8; + uOutYa += v19 - v8; + --uOutXa; + } + while ( uOutXa ); + } + } + } +} + + +//----- (004A601E) -------------------------------------------------------- +void Render::_4A601E(signed int a2, signed int a3, Texture *pTexture, int a5) +{ + signed int v5; // edx@3 + int v6; // ebx@3 + int v7; // esi@3 + void *v8; // esi@3 + unsigned int v9; // eax@4 + unsigned int v10; // eax@6 + signed int v11; // edi@8 + unsigned int v12; // eax@10 + signed int v13; // edi@11 + unsigned int v14; // edi@14 + unsigned int v15; // eax@16 + unsigned int v16; // ecx@17 + int v17; // [sp+18h] [bp+Ch]@3 + unsigned int pTexturea; // [sp+1Ch] [bp+10h]@3 + + if ( this->uNumSceneBegins && pTexture ) + { + v5 = a3; + v6 = pTexture->uTextureHeight; + v7 = 5 * a3; + v17 = pTexture->uTextureHeight; + v8 = &this->pActiveZBuffer[a2 + (v7 << 7)]; + pTexturea = pTexture->uTextureWidth; + if ( this->bClip ) + { + v9 = this->uClipX; + if ( a2 < (signed int)v9 ) + { + pTexturea += a2 - v9; + v8 = (char *)v8 + 4 * (v9 - a2); + } + v10 = this->uClipY; + if ( v5 < (signed int)v10 ) + { + v17 += v5 - v10; + v8 = (char *)v8 + 2560 * (v10 - v5); + } + v11 = this->uClipX; + if ( v11 < a2 ) + v11 = a2; + v12 = this->uClipZ; + if ( (signed int)(pTexturea + v11) > (signed int)v12 ) + { + v13 = this->uClipX; + if ( v13 < a2 ) + v13 = a2; + pTexturea = v12 - v13; + } + v14 = this->uClipY; + if ( (signed int)v14 < v5 ) + v14 = v5; + v6 = v17; + v15 = this->uClipW; + if ( (signed int)(v17 + v14) > (signed int)v15 ) + { + v16 = this->uClipY; + if ( (signed int)v16 < v5 ) + v16 = v5; + v6 = v15 - v16; + } + } + if ( v6 > 0 ) + { + do + { + if ( (signed int)pTexturea > 0 ) + { + memset32(v8, a5, pTexturea); + v8 = (char *)v8 + 4 * pTexturea; + } + v8 = (char *)v8 + 4 * (640 - pTexturea); + --v6; + } + while ( v6 ); + } + } +} + +//----- (004A5EB2) -------------------------------------------------------- +void Render::DrawTextureIndexed(unsigned int uX, unsigned int uY, Texture *a4) +{ + Texture *v4; // edi@2 + unsigned int v5; // ebx@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 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 + int v20; // [sp+1Ch] [bp-4h]@4 + int uXa; // [sp+28h] [bp+8h]@24 + unsigned int uYa; // [sp+2Ch] [bp+Ch]@22 + unsigned int v23; // [sp+30h] [bp+10h]@11 + + if ( this->uNumSceneBegins ) + { + v4 = a4; + if ( a4 ) + { + if ( a4->pPalette16 ) + { + v5 = a4->uTextureHeight; + pTarget = &this->pTargetSurface[uX + uY * this->uTargetSurfacePitch]; + v19 = a4->pLevelOfDetail0; + v20 = a4->uTextureWidth; + v18 = a4->uTextureWidth; + if ( this->bClip ) + { + v7 = this->uClipX; + if ( (signed int)uX < (signed int)v7 ) + { + v8 = v7 - uX; + v19 += v8; + v20 += uX - this->uClipX; + pTarget += v8; + } + 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; + } + v11 = this->uClipX; + if ( (signed int)v11 < (signed int)uX ) + v11 = uX; + v23 = this->uClipZ; + if ( (signed int)(v11 + v20) > (signed int)v23 ) + { + v12 = this->uClipX; + if ( (signed int)v12 < (signed int)uX ) + v12 = uX; + 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 ) + { + v15 = this->uClipY; + if ( (signed int)v15 < (signed int)uY ) + v15 = uY; + v5 = v14 - v15; + } + } + if ( (signed int)v5 > 0 ) + { + uYa = v5; + v16 = v19; + do + { + if ( v20 > 0 ) + { + uXa = v20; + do + { + *pTarget = v4->pPalette16[*v16]; + ++pTarget; + ++v16; + --uXa; + } + while ( uXa ); + } + v16 += v18 - v20; + v17 = uYa-- == 1; + pTarget += this->uTargetSurfacePitch - v20; + } + while ( !v17 ); + } + } + } + } +} + +//----- (004667E9) -------------------------------------------------------- +void Render::ChangeBetweenWinFullscreenModes() +{ + float v0; // ST14_4@17 + int v1; // edx@24 + signed int v2; // ecx@24 + int v3; // esi@25 + int v4; // edx@26 + ObjectDesc *v5; // eax@26 + RGBTexture *v6; // esi@33 + const char *v7; // eax@34 + const char *v8; // [sp-4h] [bp-28h]@33 + int v9; // [sp+0h] [bp-24h]@33 + struct tagRECT Rect; // [sp+14h] [bp-10h]@15 + + if ( pRenderer->bWindowMode ) + goto LABEL_52; + if ( dword_6BE364_game_settings_1 & 2 ) + { + ModalWindow(pGlobalTXT_LocalizationStrings[62], 0);// "Might and Magic VII requires your desktop to be in 16bit (32k or 65k) Color mode in order to operate in a window." + return; + } + if ( !pRenderer->pRenderD3D || pRenderer->pRenderD3D->pAvailableDevices->bIsDeviceCompatible ) + { +LABEL_52: + if ( pEventTimer->bPaused ) + BYTE1(dword_6BE364_game_settings_1) |= 8u; + else + pEventTimer->Pause(); + if ( pMiscTimer->bPaused ) + BYTE1(dword_6BE364_game_settings_1) |= 0x10u; + else + pMiscTimer->Pause(); + pMouse->bActive = 0; + if ( pRenderer->pRenderD3D ) + { + pBitmaps_LOD->ReleaseHardwareTextures(); + pSprites_LOD->ReleaseAll(); + } + if ( pRenderer->bWindowMode ) + { + if ( GetWindowRect(hWnd, &Rect) ) + { + WriteWindowsRegistryInt("window X", Rect.left); + WriteWindowsRegistryInt("window Y", Rect.top); + uWindowX = Rect.left; + uWindowY = Rect.top; + } + SetMenu(hWnd, 0); + SetWindowLongA(hWnd, -20, 0); + SetWindowLongA(hWnd, -16, 0x10000000u); + pRenderer->InitializeFullscreen(hWnd); + v0 = (double)(signed int)uGammaPos * 0.1 + 0.6; + pGame->pGammaController->Initialize(v0); + } + else + { + ClipCursor(0); + pRenderer->SwitchToWindow(hWnd); + SetWindowLongA(hWnd, -16, uWindowStyle); + SetMenu(hWnd, hOSMenu); + } + if ( pRenderer->pRenderD3D ) + { + pBitmaps_LOD->_410423_move_textures_to_device(); + pSprites_LOD->MoveSpritesToVideoMemory(); + } + if ( pPaletteManager->uNumTargetBBits == pRenderer->uTargetBBits + && pPaletteManager->uNumTargetGBits == pRenderer->uTargetGBits + && pPaletteManager->uNumTargetRBits == pRenderer->uTargetRBits ) + goto LABEL_38; + pPaletteManager->SetColorChannelInfo(pRenderer->uTargetRBits, pRenderer->uTargetGBits, pRenderer->uTargetBBits); + pPaletteManager->RecalculateAll(); + pBitmaps_LOD->SetupPalettes(pRenderer->uTargetRBits, pRenderer->uTargetGBits, pRenderer->uTargetBBits); + pIcons_LOD->SetupPalettes(pRenderer->uTargetRBits, pRenderer->uTargetGBits, pRenderer->uTargetBBits); + v2 = 0; + if ( (signed int)pObjectList->uNumObjects > 0 ) + { + v3 = 0; + do + { + BYTE3(v4) = 0; + v5 = &pObjectList->pObjects[v3]; + ++v3; + *(short *)((char *)&v4 + 1) = v5->uParticleTrailColorR; + LOBYTE(v4) = v5->uParticleTrailColorG; + v1 = v5->uParticleTrailColorB | (v4 << 8); + ++v2; + v5->uParticleTrailColor = v1; + } + while ( v2 < (signed int)pObjectList->uNumObjects ); + } + LOBYTE(v1) = 1; + SetUserInterface(pParty->uAlignment, v1); + if ( pVideoPlayer->pVideoFrame.pPixels ) + pVideoPlayer->pVideoFrame.Load(pVideoPlayer->pVideoFrameTextureFilename, 1); + if ( uCurrentMenuID ) + { + if ( uCurrentMenuID != 6 ) + { + if ( uCurrentMenuID == 8 ) + dword_A74C88 = 1; + goto LABEL_38; + } + v6 = &pTexture_PCX; + pTexture_PCX.Release(); + v9 = 0; + v8 = "makeme.pcx"; + } + else + { + v6 = &pTexture_PCX; + pTexture_PCX.Release(); + v7 = "title.pcx"; + if ( uCurrentMenuID ) + v7 = "lsave640.pcx"; + v9 = 0; + v8 = v7; + } + v6->Load(v8, v9); +LABEL_38: + viewparams->bRedrawGameUI = 1; + viewparams->_443343(); + pMouse->SetCurrentCursorBitmap(); + if ( pRenderer->bWindowMode ) + { + InvalidateRect(0, 0, 0); + MoveWindow(hWnd, uWindowX, uWindowY, uWindowWidth, uWindowHeight, 0); + ShowWindow(hWnd, 1); + } + pMouse->bActive = 1; + if ( pVideoPlayer->AnyMovieLoaded() ) + pVideoPlayer->_4BF73A(); + if ( BYTE1(dword_6BE364_game_settings_1) & 8 ) + BYTE1(dword_6BE364_game_settings_1) &= 0xF7u; + else + pEventTimer->Resume(); + if ( BYTE1(dword_6BE364_game_settings_1) & 0x10 ) + BYTE1(dword_6BE364_game_settings_1) &= 0xEFu; + else + pMiscTimer->Resume(); + pAsyncMouse->Release(); + CreateAsyncMouse(); + if (pAsyncMouse) + pAsyncMouse->Clip(); + } +} +// 6BE364: using guessed type int dword_6BE364_game_settings_1; +// A74C88: using guessed type int dword_A74C88; + + +//----- (0044EC20) -------------------------------------------------------- +bool RenderD3D::DoesRaiseExceptions() +{ + return true; +} + + +//----- (0040DBD3) -------------------------------------------------------- +void __fastcall Render::SetPixel(Vec2_int_ *pTargetXY, unsigned __int16 uColor) +{ + Vec2_int_ *pTargetXY_; // esi@1 + unsigned __int16 v3; // di@1 + signed int v4; // ecx@2 + signed int v5; // eax@4 + + pTargetXY_ = pTargetXY; + v3 = uColor; + pRenderer->BeginScene(); + if ( pRenderer->uNumSceneBegins ) + { + v4 = pTargetXY_->x; + if ( pTargetXY_->x >= 0 ) + { + if ( v4 <= 639 ) + { + v5 = pTargetXY_->y; + if ( v5 >= 0 ) + { + if ( v5 <= 479 ) + pRenderer->pTargetSurface[v4 + pRenderer->uTargetSurfacePitch * v5] = v3; + } + } + } + pRenderer->EndScene(); + } +} + + +//----- (004524D8) -------------------------------------------------------- +HWLTexture *RenderHWLContainer::LoadTexture(const char *pName, int bMipMaps) +{ + int v11; // eax@13 + int v12; // ecx@13 + void *v13; // eax@13 + unsigned __int8 v14; // zf@13 + unsigned __int8 v15; // sf@13 + int v16; // esi@14 + int v17; // ecx@16 + int v18; // esi@16 + unsigned __int16 *v19; // eax@16 + int v20; // edx@16 + int v21; // ecx@16 + int v22; // eax@16 + int v23; // esi@16 + unsigned __int16 *v26; // [sp+24h] [bp-10h]@13 + int v27; // [sp+28h] [bp-Ch]@14 + int v28; // [sp+2Ch] [bp-8h]@13 + int pDestb; // [sp+3Ch] [bp+8h]@15 + + //v3 = this; + //sprintf(Str1, "%s", pName); + //v4 = uNumItems; + if (!uNumItems) + return nullptr; + + //{ + //v5 = 0, pDesta = uNumItems; + uint idx1 = 0, + idx2 = uNumItems; + while (true) + { + auto i = idx1 + (idx2 - idx1) / 2; + + auto res = strcmpi(pName, pSpriteNames[i]); + if (!res) + { + fseek(pFile, pSpriteOffsets[i], SEEK_SET); + break; + } + else if (res < 0) + idx2 = idx1 + (idx2 - idx1) / 2; + else + idx1 = i + 1; + + if ( idx1 >= idx2 ) + return false; + } + + + uint uCompressedSize = 0; + fread(&uCompressedSize, 4, 1, pFile); + + auto pTex = new HWLTexture; + fread(&pTex->field_18, 4, 1, pFile); + fread(&pTex->field_1C, 4, 1, pFile); + fread(&pTex->field_20, 4, 1, pFile); + fread(&pTex->field_24, 4, 1, pFile); + fread(&pTex->uWidth, 4, 1, pFile); + fread(&pTex->uHeight, 4, 1, pFile); + fread(&pTex->field_30, 4, 1, pFile); + fread(&pTex->field_34, 4, 1, pFile); + + pTex->pPixels = new unsigned __int16[pTex->uWidth * pTex->uHeight]; + if (uCompressedSize) + { + auto pCompressedData = new char[uCompressedSize]; + { + fread(pCompressedData, 1, uCompressedSize, pFile); + auto uDecompressedSize = pTex->uWidth * pTex->uHeight * sizeof(short); + zlib::MemUnzip(pTex->pPixels, &uDecompressedSize, pCompressedData, uCompressedSize); + } + delete [] pCompressedData; + } + else + fread(pTex->pPixels, 2, pTex->uWidth * pTex->uHeight, pFile); + + if ( field_61A94_scale_hwls_to_half ) + { + v11 = pTex->uHeight / 2; + v12 = pTex->uWidth / 2; + pTex->uHeight = v11; + pTex->uWidth = v12; + v13 = new unsigned __int16[v12 * v11]; + v28 = 0; + v14 = pTex->uHeight == 0; + v15 = (pTex->uHeight & 0x80000000u) != 0; + v26 = (unsigned __int16 *)v13; + if ( !(v15 | v14) ) + { + v16 = pTex->uWidth; + v27 = 1; + do + { + pDestb = 0; + if ( v16 > 0 ) + { + do + { + v17 = v16 * v27; + v18 = v28 * v16; + v19 = pTex->pPixels; + v20 = pDestb + 2 * v18; + v21 = (int)&v19[2 * (pDestb + v17)]; + v22 = (int)&v19[2 * v20]; + LOWORD(v20) = *(unsigned short *)(v21 + 2); + LOWORD(v21) = *(unsigned short *)v21; + v23 = pDestb++ + v18; + v26[v23] = sub_452442(*(unsigned short *)v22, *(unsigned short *)(v22 + 2), v21, v20); + v16 = pTex->uWidth; + } + while (pDestb < pTex->uWidth); + } + ++v28; + v27 += 2; + } + while ( v28 < (signed int)pTex->uHeight ); + } + delete [] pTex->pPixels; + pTex->pPixels = v26; + } + return pTex; + //result = pTex; +// } +// else +// { +//LABEL_8: +// return nullptr; +// } +} + +//----- (0045271F) -------------------------------------------------------- +bool RenderHWLContainer::Release() +{ + RenderHWLContainer *v1; // esi@1 + int v2; // ebx@1 + void **v3; // edi@3 + __int32 v4; // eax@6 + FILE *v5; // ST24_4@6 + size_t *v6; // edi@6 + int v7; // ebx@7 + signed int v9; // [sp+0h] [bp-8h]@6 + FILE *File; // [sp+4h] [bp-4h]@6 + + v1 = this; + v2 = 0; + if ( this->bDumpDebug ) + { + File = fopen("logd3d.txt", "w"); + v4 = ftell(v1->pFile); + v5 = v1->pFile; + v6 = &v1->uNumItems; + v1->uDataOffset = v4; + fwrite(&v1->uNumItems, 4u, 1u, v5); + v9 = 0; + if ( (signed int)v1->uNumItems > 0 ) + { + v7 = (int)v1->pSpriteNames; + do + { + fwrite(*(const void **)v7, 1u, 0x14u, v1->pFile); + fprintf(File, "D3D texture name: %s\t\toffset: %x\n", *(unsigned int *)v7, *(unsigned int *)(v7 + 200000)); + ++v9; + v7 += 4; + } + while ( v9 < (signed int)*v6 ); + v2 = 0; + } + fwrite(v1->pSpriteOffsets, 4u, *v6, v1->pFile); + fseek(v1->pFile, 4, v2); + fwrite(&v1->uDataOffset, 4u, 1u, v1->pFile); + fclose(v1->pFile); + fclose(File); + } + else + { + fclose(this->pFile); + if ( (signed int)v1->uNumItems > 0 ) + { + v3 = (void **)v1->pSpriteNames; + do + { + free(*v3); + ++v2; + ++v3; + } + while ( v2 < (signed int)v1->uNumItems ); + } + } + return 1; +} + +//----- (00452347) -------------------------------------------------------- +RenderHWLContainer::RenderHWLContainer(): + bDumpDebug(false) +{ + RenderHWLContainer *v1; // esi@1 + + v1 = this; + this->pFile = 0; + uSignature = 0; + v1->uDataOffset = 0; + memset(&v1->uNumItems, 0, 0x61A84u); + v1->uNumItems = 0; + v1->field_61A94_scale_hwls_to_half = 0; +} + +//----- (0045237F) -------------------------------------------------------- +bool RenderHWLContainer::Load(const wchar_t *pFilename) +{ + pFile = _wfopen(pFilename, L"rb"); + if (!pFile) + { + Log::Warning(L"Failed to open file: %s", pFilename); + return false; + } + + fread(&uSignature, 1, 4, pFile); + if (uSignature != 'TD3D') + { + Log::Warning(L"Invalid format: %s", pFilename); + return false; + } + + fread(&uDataOffset, 4, 1, pFile); + fseek(pFile, uDataOffset, SEEK_SET); + fread(&uNumItems, 4, 1, pFile); + + memset(pSpriteNames, 0, 50000 * sizeof(char *)); + for (uint i = 0; i < uNumItems; ++i) + { + pSpriteNames[i] = new char[20]; + fread(pSpriteNames[i], 1, 20, pFile); + } + fread(pSpriteOffsets, 4, uNumItems, pFile); + + return true; +} + + + + + + + + + +//----- (004A1C1E) -------------------------------------------------------- +void DoRenderBillboards_D3D() +{ + ErrD3D(pRenderer->pRenderD3D->pDevice->SetTextureStageState(0, D3DTSS_ADDRESS, 3u)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ALPHABLENDENABLE, 1u)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ZWRITEENABLE, 0)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_CULLMODE, 1u)); + + for (uint i = pRenderer->uNumBillboardsToDraw - 1; i != (uint)-1; --i) + { + auto p = pRenderer->pBillboardRenderListD3D + i; + + if (p->uOpacity != RenderBillboardD3D::InvalidOpacity) + SetBillboardBlendOptions(p->uOpacity); + + ErrD3D(pRenderer->pRenderD3D->pDevice->SetTexture(0, p->pTexture)); + ErrD3D(pRenderer->pRenderD3D->pDevice->DrawPrimitive(D3DPT_TRIANGLEFAN, D3DFVF_XYZRHW | D3DFVF_DIFFUSE | D3DFVF_SPECULAR | D3DFVF_TEX1, + p->pQuards, p->uNumVertices, D3DDP_DONOTLIGHT | D3DDP_DONOTUPDATEEXTENTS)); + } + + if (pRenderer->bFogEnabled) + { + pRenderer->bFogEnabled = false; + ErrD3D(pRenderer->pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_FOGENABLE, 1)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_FOGCOLOR, GetLevelFogColor() & 0xFFFFFF)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_FOGTABLEMODE, 0)); + } + ErrD3D(pRenderer->pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_CULLMODE, 2)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ZWRITEENABLE, 1)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_ALPHABLENDENABLE, 0)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, 2u)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, 1u)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_DITHERENABLE, 1u)); +} + + + + + +//----- (004A1DA8) -------------------------------------------------------- +void SetBillboardBlendOptions(RenderBillboardD3D::OpacityType a1) +{ + switch (a1) + { + case RenderBillboardD3D::Transparent: + { + if (pRenderer->bFogEnabled) + { + pRenderer->bFogEnabled = false; + ErrD3D(pRenderer->pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_FOGENABLE, 1u)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_FOGCOLOR, GetLevelFogColor() & 0xFFFFFF)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_FOGTABLEMODE, 0)); + } + + ErrD3D(pRenderer->pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, 5)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, 6u)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_DITHERENABLE, 1)); + } + break; + + case RenderBillboardD3D::Opaque_1: + case RenderBillboardD3D::Opaque_2: + case RenderBillboardD3D::Opaque_3: + { + if (pRenderer->bUsingSpecular) + { + if (!pRenderer->bFogEnabled) + { + pRenderer->bFogEnabled = true; + ErrD3D(pRenderer->pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_FOGENABLE, 0)); + } + } + + ErrD3D(pRenderer->pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_SRCBLEND, 2)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_DESTBLEND, 2u)); + ErrD3D(pRenderer->pRenderD3D->pDevice->SetRenderState(D3DRENDERSTATE_DITHERENABLE, 0)); + } + break; + + default: + Log::Warning(L"SetBillboardBlendOptions: invalid opacity type (%u)", a1); + break; + } +} +