From d5bfb594096ceebd8a7c82fe90549b7d95b501e4 Mon Sep 17 00:00:00 2001 From: Toni Wilen Date: Sun, 13 Aug 2017 16:03:22 +0300 Subject: [PATCH] Preliminary changes for future multi-window support. --- od-win32/direct3d.cpp | 1734 +++++++++++++++++++++-------------------- od-win32/direct3d.h | 3 +- 2 files changed, 892 insertions(+), 845 deletions(-) diff --git a/od-win32/direct3d.cpp b/od-win32/direct3d.cpp index cf3e05a1..27b3bb5b 100644 --- a/od-win32/direct3d.cpp +++ b/od-win32/direct3d.cpp @@ -42,11 +42,11 @@ int forcedframelatency = -1; #include "direct3d.h" static TCHAR *D3DHEAD = _T("-"); -static int psEnabled, psActive; static struct gfx_filterdata *filterd3d; static int filterd3didx; static bool showoverlay = true; +int fakemodewaitms; #define MAX_PASSES 2 @@ -96,67 +96,88 @@ struct shaderdata // Stuff D3DXHANDLE framecounterHandle; }; -static LPDIRECT3DTEXTURE9 lpPostTempTexture; #define MAX_SHADERS (2 * MAX_FILTERSHADERS + 2) #define SHADER_POST 0 -static struct shaderdata shaders[MAX_SHADERS]; - -static IDirect3DSurface9 *screenshotsurface; -static D3DFORMAT tformat; -static int d3d_enabled, d3d_ex; -static IDirect3D9 *d3d; -static IDirect3D9Ex *d3dex; -static IDirect3DSwapChain9 *d3dswapchain; -static D3DPRESENT_PARAMETERS dpp; -static D3DDISPLAYMODEEX modeex; -static IDirect3DDevice9 *d3ddev; -static IDirect3DDevice9Ex *d3ddevex; -static D3DSURFACE_DESC dsdbb; -static LPDIRECT3DTEXTURE9 texture, sltexture, ledtexture, mask2texture, blanktexture; -static IDirect3DQuery9 *query; -static float mask2texture_w, mask2texture_h, mask2texture_ww, mask2texture_wh; -static float mask2texture_wwx, mask2texture_hhx, mask2texture_minusx, mask2texture_minusy; -static float mask2texture_multx, mask2texture_multy, mask2texture_offsetw; -LPDIRECT3DTEXTURE9 cursorsurfaced3d; -static IDirect3DVertexBuffer9 *vertexBuffer; -static ID3DXSprite *sprite; -static HWND d3dhwnd; -static int devicelost; -static int locked, fulllocked; -static int cursor_offset_x, cursor_offset_y, cursor_offset2_x, cursor_offset2_y; -static float maskmult_x, maskmult_y; -RECT mask2rect; -static bool wasstilldrawing_broken; -static bool renderdisabled; -static HANDLE filenotificationhandle; -static int frames_since_init; - -static volatile bool fakemode; -static uae_u8 *fakebitmap; -static uae_thread_id fakemodetid; -int fakemodewaitms = 0; - -static D3DXMATRIXA16 m_matProj, m_matProj2, m_matProj_out; -static D3DXMATRIXA16 m_matWorld, m_matWorld2, m_matWorld_out; -static D3DXMATRIXA16 m_matView, m_matView2, m_matView_out; -static D3DXMATRIXA16 m_matPreProj; -static D3DXMATRIXA16 m_matPreView; -static D3DXMATRIXA16 m_matPreWorld; -static D3DXMATRIXA16 postproj; -static D3DXVECTOR4 maskmult, maskshift; -static D3DXVECTOR4 fakesize; - -static int ledwidth, ledheight; -static int max_texture_w, max_texture_h; -static int tin_w, tin_h, tout_w, tout_h, window_h, window_w; -static int t_depth, dmult, dmultx; -static int required_sl_texture_w, required_sl_texture_h; -static int vsync2, guimode, maxscanline, variablerefresh; -static int resetcount; -static double cursor_x, cursor_y; -static bool cursor_v, cursor_scale; -static int statusbar_vx = 1, statusbar_hx = 1; + +struct d3dstruct +{ + int psEnabled, psActive; + struct shaderdata shaders[MAX_SHADERS]; + LPDIRECT3DTEXTURE9 lpPostTempTexture; + IDirect3DSurface9 *screenshotsurface; + D3DFORMAT tformat; + int d3d_enabled, d3d_ex; + IDirect3D9 *d3d; + IDirect3D9Ex *d3dex; + IDirect3DSwapChain9 *d3dswapchain; + D3DPRESENT_PARAMETERS dpp; + D3DDISPLAYMODEEX modeex; + IDirect3DDevice9 *d3ddev; + IDirect3DDevice9Ex *d3ddevex; + D3DSURFACE_DESC dsdbb; + LPDIRECT3DTEXTURE9 texture, sltexture, ledtexture, mask2texture, blanktexture; + IDirect3DQuery9 *query; + float mask2texture_w, mask2texture_h, mask2texture_ww, mask2texture_wh; + float mask2texture_wwx, mask2texture_hhx, mask2texture_minusx, mask2texture_minusy; + float mask2texture_multx, mask2texture_multy, mask2texture_offsetw; + LPDIRECT3DTEXTURE9 cursorsurfaced3d; + IDirect3DVertexBuffer9 *vertexBuffer; + ID3DXSprite *sprite; + HWND d3dhwnd; + int devicelost; + int locked, fulllocked; + int cursor_offset_x, cursor_offset_y, cursor_offset2_x, cursor_offset2_y; + float maskmult_x, maskmult_y; + RECT mask2rect; + bool wasstilldrawing_broken; + bool renderdisabled; + HANDLE filenotificationhandle; + int frames_since_init; + + volatile bool fakemode; + uae_u8 *fakebitmap; + uae_thread_id fakemodetid; + + D3DXMATRIXA16 m_matProj, m_matProj2, m_matProj_out; + D3DXMATRIXA16 m_matWorld, m_matWorld2, m_matWorld_out; + D3DXMATRIXA16 m_matView, m_matView2, m_matView_out; + D3DXMATRIXA16 m_matPreProj; + D3DXMATRIXA16 m_matPreView; + D3DXMATRIXA16 m_matPreWorld; + D3DXMATRIXA16 postproj; + D3DXVECTOR4 maskmult, maskshift; + D3DXVECTOR4 fakesize; + + int ledwidth, ledheight; + int max_texture_w, max_texture_h; + int tin_w, tin_h, tout_w, tout_h, window_h, window_w; + int t_depth, dmult, dmultx; + int required_sl_texture_w, required_sl_texture_h; + int vsync2, guimode, maxscanline, variablerefresh; + int resetcount; + double cursor_x, cursor_y; + bool cursor_v, cursor_scale; + int statusbar_vx, statusbar_hx; + + D3DXHANDLE postSourceTextureHandle; + D3DXHANDLE postMaskTextureHandle; + D3DXHANDLE postTechnique, postTechniquePlain, postTechniqueAlpha; + D3DXHANDLE postMatrixSource; + D3DXHANDLE postMaskMult, postMaskShift; + D3DXHANDLE postFilterMode; + D3DXHANDLE postTexelSize; + D3DXHANDLE postFramecounterHandle; + + float m_scale; + LPCSTR m_strName; + + int ddraw_fs; + int ddraw_fs_attempt; + LPDIRECTDRAW7 ddraw; +}; + +static struct d3dstruct d3ddata[1]; #define NUMVERTICES 8 #define D3DFVF_TLVERTEX D3DFVF_XYZ|D3DFVF_DIFFUSE|D3DFVF_TEX1 @@ -166,65 +187,61 @@ struct TLVERTEX { D3DXVECTOR2 texcoord; // texture coords }; -static int ddraw_fs; -static int ddraw_fs_attempt; -static LPDIRECTDRAW7 ddraw; -static void ddraw_fs_hack_free (void) +static void ddraw_fs_hack_free (struct d3dstruct *d3d) { HRESULT hr; - if (!ddraw_fs) + if (!d3d->ddraw_fs) return; - if (ddraw_fs == 2) - ddraw->RestoreDisplayMode (); - hr = ddraw->SetCooperativeLevel (d3dhwnd, DDSCL_NORMAL); + if (d3d->ddraw_fs == 2) + d3d->ddraw->RestoreDisplayMode (); + hr = d3d->ddraw->SetCooperativeLevel (d3d->d3dhwnd, DDSCL_NORMAL); if (FAILED (hr)) { write_log (_T("IDirectDraw7_SetCooperativeLevel CLEAR: %s\n"), DXError (hr)); } - ddraw->Release (); - ddraw = NULL; - ddraw_fs = 0; - + d3d->ddraw->Release (); + d3d->ddraw = NULL; + d3d->ddraw_fs = 0; } -static int ddraw_fs_hack_init (void) +static int ddraw_fs_hack_init (struct d3dstruct *d3d) { HRESULT hr; struct MultiDisplay *md; - ddraw_fs_hack_free (); + ddraw_fs_hack_free (d3d); DirectDraw_get_GUIDs (); md = getdisplay (&currprefs); if (!md) return 0; - hr = DirectDrawCreateEx (md->primary ? NULL : &md->ddguid, (LPVOID*)&ddraw, IID_IDirectDraw7, NULL); + hr = DirectDrawCreateEx (md->primary ? NULL : &md->ddguid, (LPVOID*)&d3d->ddraw, IID_IDirectDraw7, NULL); if (FAILED (hr)) { write_log (_T("DirectDrawCreateEx failed, %s\n"), DXError (hr)); return 0; } - ddraw_fs = 1; - hr = ddraw->SetCooperativeLevel (d3dhwnd, DDSCL_ALLOWREBOOT | DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN); + d3d->ddraw_fs = 1; + hr = d3d->ddraw->SetCooperativeLevel (d3d->d3dhwnd, DDSCL_ALLOWREBOOT | DDSCL_EXCLUSIVE | DDSCL_FULLSCREEN); if (FAILED (hr)) { write_log (_T("IDirectDraw7_SetCooperativeLevel SET: %s\n"), DXError (hr)); - ddraw_fs_hack_free (); + ddraw_fs_hack_free (d3d); return 0; } - hr = ddraw->SetDisplayMode (dpp.BackBufferWidth, dpp.BackBufferHeight, t_depth, dpp.FullScreen_RefreshRateInHz, 0); + hr = d3d->ddraw->SetDisplayMode (d3d->dpp.BackBufferWidth, d3d->dpp.BackBufferHeight, d3d->t_depth, d3d->dpp.FullScreen_RefreshRateInHz, 0); if (FAILED (hr)) { write_log (_T("1:IDirectDraw7_SetDisplayMode: %s\n"), DXError (hr)); - if (dpp.FullScreen_RefreshRateInHz && isvsync_chipset () < 0) { - hr = ddraw->SetDisplayMode (dpp.BackBufferWidth, dpp.BackBufferHeight, t_depth, 0, 0); + if (d3d->dpp.FullScreen_RefreshRateInHz && isvsync_chipset () < 0) { + hr = d3d->ddraw->SetDisplayMode (d3d->dpp.BackBufferWidth, d3d->dpp.BackBufferHeight, d3d->t_depth, 0, 0); if (FAILED (hr)) write_log (_T("2:IDirectDraw7_SetDisplayMode: %s\n"), DXError (hr)); } if (FAILED (hr)) { write_log (_T("IDirectDraw7_SetDisplayMode: %s\n"), DXError (hr)); - ddraw_fs_hack_free (); + ddraw_fs_hack_free (d3d); return 0; } } - ddraw_fs = 2; + d3d->ddraw_fs = 2; return 1; } @@ -298,70 +315,59 @@ static TCHAR *D3DX_ErrorString (HRESULT hr, LPD3DXBUFFER Errors) return buffer; } -static int isd3d (void) +static int isd3d (struct d3dstruct *d3d) { - if (fakemode || devicelost || !d3ddev || !d3d_enabled || renderdisabled) + if (d3d->fakemode || d3d->devicelost || !d3d->d3ddev || !d3d->d3d_enabled || d3d->renderdisabled) return 0; return 1; } -static void waitfakemode (void) +static void waitfakemode (struct d3dstruct *d3d) { - while (fakemode) { + while (d3d->fakemode) { sleep_millis (10); } } -static D3DXHANDLE postSourceTextureHandle; -static D3DXHANDLE postMaskTextureHandle; -static D3DXHANDLE postTechnique, postTechniquePlain, postTechniqueAlpha; -static D3DXHANDLE postMatrixSource; -static D3DXHANDLE postMaskMult, postMaskShift; -static D3DXHANDLE postFilterMode; -static D3DXHANDLE postTexelSize; -static D3DXHANDLE postFramecounterHandle; - -static float m_scale; -static LPCSTR m_strName; enum psEffect_Pass { psEffect_None, psEffect_PreProcess1, psEffect_PreProcess2, psEffect_Combine }; -static int postEffect_ParseParameters (LPD3DXEFFECTCOMPILER EffectCompiler, LPD3DXEFFECT effect, struct shaderdata *s) -{ - postSourceTextureHandle = effect->GetParameterByName (NULL, "SourceTexture"); - postMaskTextureHandle = effect->GetParameterByName (NULL, "OverlayTexture"); - postTechnique = effect->GetTechniqueByName ("PostTechnique"); - postTechniquePlain = effect->GetTechniqueByName ("PostTechniquePlain"); - postTechniqueAlpha = effect->GetTechniqueByName ("PostTechniqueAlpha"); - postMatrixSource = effect->GetParameterByName (NULL, "mtx"); - postMaskMult = effect->GetParameterByName (NULL, "maskmult"); - postMaskShift = effect->GetParameterByName (NULL, "maskshift"); - postFilterMode = effect->GetParameterByName (NULL, "filtermode"); - postTexelSize = effect->GetParameterByName (NULL, "texelsize"); - postFramecounterHandle = effect->GetParameterByName (NULL, "framecounter"); - - if (!postMaskShift || !postMaskMult || !postFilterMode || !postMatrixSource || !postTexelSize) { +static int postEffect_ParseParameters (struct d3dstruct *d3d, LPD3DXEFFECTCOMPILER EffectCompiler, LPD3DXEFFECT effect, struct shaderdata *s) +{ + d3d->postSourceTextureHandle = effect->GetParameterByName (NULL, "SourceTexture"); + d3d->postMaskTextureHandle = effect->GetParameterByName (NULL, "OverlayTexture"); + d3d->postTechnique = effect->GetTechniqueByName ("PostTechnique"); + d3d->postTechniquePlain = effect->GetTechniqueByName ("PostTechniquePlain"); + d3d->postTechniqueAlpha = effect->GetTechniqueByName ("PostTechniqueAlpha"); + d3d->postMatrixSource = effect->GetParameterByName (NULL, "mtx"); + d3d->postMaskMult = effect->GetParameterByName (NULL, "maskmult"); + d3d->postMaskShift = effect->GetParameterByName (NULL, "maskshift"); + d3d->postFilterMode = effect->GetParameterByName (NULL, "filtermode"); + d3d->postTexelSize = effect->GetParameterByName (NULL, "texelsize"); + d3d->postFramecounterHandle = effect->GetParameterByName (NULL, "framecounter"); + + if (!d3d->postMaskShift || !d3d->postMaskMult || !d3d->postFilterMode || !d3d->postMatrixSource || !d3d->postTexelSize) { gui_message (_T("Mismatched _winuae.fx! Exiting..")); abort (); } return true; } -static void postEffect_freeParameters(void) +static void postEffect_freeParameters(struct d3dstruct *d3d) { - postSourceTextureHandle = NULL; - postMaskTextureHandle = NULL; - postTechnique = NULL; - postTechniquePlain = NULL; - postTechniqueAlpha = NULL; - postMatrixSource = NULL; - postMaskMult = NULL; - postMaskShift = NULL; - postFilterMode = NULL; - postTexelSize = NULL; - postFramecounterHandle = NULL; + d3d->postSourceTextureHandle = NULL; + d3d->postMaskTextureHandle = NULL; + d3d->postTechnique = NULL; + d3d->postTechniquePlain = NULL; + d3d->postTechniqueAlpha = NULL; + d3d->postMatrixSource = NULL; + d3d->postMaskMult = NULL; + d3d->postMaskShift = NULL; + d3d->postFilterMode = NULL; + d3d->postTexelSize = NULL; + d3d->postFramecounterHandle = NULL; } -static int psEffect_ParseParameters (LPD3DXEFFECTCOMPILER EffectCompiler, LPD3DXEFFECT effect, D3DXEFFECT_DESC EffectDesc, struct shaderdata *s) +static int psEffect_ParseParameters (struct d3dstruct *d3d, LPD3DXEFFECTCOMPILER EffectCompiler, LPD3DXEFFECT effect, D3DXEFFECT_DESC EffectDesc, struct shaderdata *s) { HRESULT hr = S_OK; // Look at parameters for semantics and annotations that we know how to interpret @@ -419,7 +425,7 @@ static int psEffect_ParseParameters (LPD3DXEFFECTCOMPILER EffectCompiler, LPD3DX s->m_TexelSizeEffectHandle = hParam; } else if(ParamDesc.Class == D3DXPC_SCALAR && ParamDesc.Type == D3DXPT_FLOAT) { if(strcmpi(ParamDesc.Semantic, "SCALING") == 0) - hr = effect->GetFloat(hParam, &m_scale); + hr = effect->GetFloat(hParam, &d3d->m_scale); } else if(ParamDesc.Class == D3DXPC_OBJECT && ParamDesc.Type == D3DXPT_TEXTURE) { if(strcmpi(ParamDesc.Semantic, "SOURCETEXTURE") == 0) s->m_SourceTextureEffectHandle = hParam; @@ -441,7 +447,7 @@ static int psEffect_ParseParameters (LPD3DXEFFECTCOMPILER EffectCompiler, LPD3DX hr = effect->GetString(hParam, &pstrTechnique); s->m_PreprocessTechnique2EffectHandle = effect->GetTechniqueByName(pstrTechnique); } else if(strcmpi(ParamDesc.Semantic, "NAME") == 0) { - hr = effect->GetString(hParam, &m_strName); + hr = effect->GetString(hParam, &d3d->m_strName); } } if (FAILED (hr)) { @@ -505,7 +511,7 @@ static int psEffect_ParseParameters (LPD3DXEFFECTCOMPILER EffectCompiler, LPD3DX if(pstrTextureType != NULL) { if(strcmpi(pstrTextureType, "volume") == 0) { LPDIRECT3DVOLUMETEXTURE9 pVolumeTex = NULL; - if(SUCCEEDED(hr = D3DXCreateVolumeTexture(d3ddev, + if(SUCCEEDED(hr = D3DXCreateVolumeTexture(d3d->d3ddev, Width, Height, Depth, 1, 0, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &pVolumeTex))) { if(SUCCEEDED(hr = D3DXFillVolumeTextureTX(pVolumeTex, ppTextureShader))) { pTex = pVolumeTex; @@ -513,7 +519,7 @@ static int psEffect_ParseParameters (LPD3DXEFFECTCOMPILER EffectCompiler, LPD3DX } } else if(strcmpi(pstrTextureType, "cube") == 0) { LPDIRECT3DCUBETEXTURE9 pCubeTex = NULL; - if(SUCCEEDED(hr = D3DXCreateCubeTexture(d3ddev, + if(SUCCEEDED(hr = D3DXCreateCubeTexture(d3d->d3ddev, Width, D3DX_DEFAULT, 0, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &pCubeTex))) { if(SUCCEEDED(hr = D3DXFillCubeTextureTX(pCubeTex, ppTextureShader))) { pTex = pCubeTex; @@ -522,7 +528,7 @@ static int psEffect_ParseParameters (LPD3DXEFFECTCOMPILER EffectCompiler, LPD3DX } } else { LPDIRECT3DTEXTURE9 p2DTex = NULL; - if(SUCCEEDED(hr = D3DXCreateTexture(d3ddev, Width, Height, + if(SUCCEEDED(hr = D3DXCreateTexture(d3d->d3ddev, Width, Height, D3DX_DEFAULT, 0, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &p2DTex))) { if(SUCCEEDED(hr = D3DXFillTextureTX(p2DTex, ppTextureShader))) { pTex = p2DTex; @@ -826,7 +832,7 @@ static const char *fx20 = { "}\n" }; -static bool psEffect_LoadEffect (const TCHAR *shaderfile, int full, struct shaderdata *s, int num) +static bool psEffect_LoadEffect (struct d3dstruct *d3d, const TCHAR *shaderfile, int full, struct shaderdata *s, int num) { int ret = 0; LPD3DXEFFECTCOMPILER EffectCompiler = NULL; @@ -836,7 +842,7 @@ static bool psEffect_LoadEffect (const TCHAR *shaderfile, int full, struct shade TCHAR tmp[MAX_DPATH], tmp2[MAX_DPATH], tmp3[MAX_DPATH]; LPD3DXEFFECT effect = NULL; static int first; - DWORD compileflags = psEnabled ? 0 : D3DXSHADER_USE_LEGACY_D3DX9_31_DLL; + DWORD compileflags = d3d->psEnabled ? 0 : D3DXSHADER_USE_LEGACY_D3DX9_31_DLL; int canusefile = 0, existsfile = 0; bool plugin_path; D3DXEFFECT_DESC EffectDesc; @@ -866,7 +872,7 @@ static bool psEffect_LoadEffect (const TCHAR *shaderfile, int full, struct shade write_log (_T("%s: D3DXCreateEffectCompilerFromFile failed: %s\n"), D3DHEAD, D3DX_ErrorString (hr, Errors)); } if (FAILED (hr)) { - const char *str = psEnabled ? fx20 : fx10; + const char *str = d3d->psEnabled ? fx20 : fx10; int len = strlen (str); if (!existsfile && plugin_path) { struct zfile *z = zfile_fopen (tmp, _T("w")); @@ -903,7 +909,7 @@ static bool psEffect_LoadEffect (const TCHAR *shaderfile, int full, struct shade } void *bp = BufferEffect->GetBufferPointer (); int bplen = BufferEffect->GetBufferSize (); - hr = D3DXCreateEffect (d3ddev, + hr = D3DXCreateEffect (d3d->d3ddev, bp, bplen, NULL, NULL, EFFECTCOMPILERFLAGS, @@ -918,16 +924,16 @@ static bool psEffect_LoadEffect (const TCHAR *shaderfile, int full, struct shade goto end; } if (full) { - if (!psEffect_ParseParameters (EffectCompiler, effect, EffectDesc, s)) + if (!psEffect_ParseParameters (d3d, EffectCompiler, effect, EffectDesc, s)) goto end; } else { - if (!postEffect_ParseParameters (EffectCompiler, effect, s)) + if (!postEffect_ParseParameters (d3d, EffectCompiler, effect, s)) goto end; } ret = 1; - frames_since_init = 0; - if (plugin_path && filenotificationhandle == NULL) - filenotificationhandle = FindFirstChangeNotification (tmp3, FALSE, FILE_NOTIFY_CHANGE_LAST_WRITE); + d3d->frames_since_init = 0; + if (plugin_path && d3d->filenotificationhandle == NULL) + d3d->filenotificationhandle = FindFirstChangeNotification (tmp3, FALSE, FILE_NOTIFY_CHANGE_LAST_WRITE); end: if (Errors) @@ -940,7 +946,7 @@ end: if (full) { s->psPreProcess = FALSE; if (ret) { - psActive = TRUE; + d3d->psActive = TRUE; if (psEffect_hasPreProcess (s)) s->psPreProcess = TRUE; } @@ -1161,18 +1167,18 @@ static int psEffect_End (LPD3DXEFFECT effect) return 1; } -static LPDIRECT3DTEXTURE9 createtext (int w, int h, D3DFORMAT format) +static LPDIRECT3DTEXTURE9 createtext (struct d3dstruct *d3d, int w, int h, D3DFORMAT format) { LPDIRECT3DTEXTURE9 t; D3DLOCKED_RECT locked; HRESULT hr; - hr = d3ddev->CreateTexture (w, h, 1, D3DUSAGE_DYNAMIC, format, D3DPOOL_DEFAULT, &t, NULL); + hr = d3d->d3ddev->CreateTexture (w, h, 1, D3DUSAGE_DYNAMIC, format, D3DPOOL_DEFAULT, &t, NULL); if (FAILED (hr)) write_log (_T("%s: CreateTexture() D3DUSAGE_DYNAMIC failed: %s (%d*%d %08x)\n"), D3DHEAD, D3D_ErrorString (hr), w, h, format); if (FAILED (hr)) { - hr = d3ddev->CreateTexture (w, h, 1, 0, format, D3DPOOL_DEFAULT, &t, NULL); + hr = d3d->d3ddev->CreateTexture (w, h, 1, 0, format, D3DPOOL_DEFAULT, &t, NULL); } if (FAILED (hr)) { write_log (_T("%s: CreateTexture() failed: %s (%d*%d %08x)\n"), @@ -1195,93 +1201,93 @@ static LPDIRECT3DTEXTURE9 createtext (int w, int h, D3DFORMAT format) return t; } -static int allocextratextures (struct shaderdata *s, int w, int h) +static int allocextratextures (struct d3dstruct *d3d, struct shaderdata *s, int w, int h) { HRESULT hr; - if (FAILED (hr = d3ddev->CreateTexture (w, h, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &s->lpWorkTexture1, NULL))) { - write_log (_T("%s: Failed to create working texture1: %s:%d\n"), D3DHEAD, D3D_ErrorString (hr), s - &shaders[0]); + if (FAILED (hr = d3d->d3ddev->CreateTexture (w, h, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &s->lpWorkTexture1, NULL))) { + write_log (_T("%s: Failed to create working texture1: %s:%d\n"), D3DHEAD, D3D_ErrorString (hr), s - &d3d->shaders[0]); return 0; } - if (FAILED (hr = d3ddev->CreateTexture (w, h, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &s->lpWorkTexture2, NULL))) { - write_log (_T("%s: Failed to create working texture2: %s:%d\n"), D3DHEAD, D3D_ErrorString (hr), s - &shaders[0]); + if (FAILED (hr = d3d->d3ddev->CreateTexture (w, h, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &s->lpWorkTexture2, NULL))) { + write_log (_T("%s: Failed to create working texture2: %s:%d\n"), D3DHEAD, D3D_ErrorString (hr), s - &d3d->shaders[0]); return 0; } - write_log (_T("%s: %d*%d working texture:%d\n"), D3DHEAD, w, h, s - &shaders[0]); + write_log (_T("%s: %d*%d working texture:%d\n"), D3DHEAD, w, h, s - &d3d->shaders[0]); return 1; } -static int createamigatexture (int w, int h) +static int createamigatexture (struct d3dstruct *d3d, int w, int h) { HRESULT hr; - texture = createtext (w, h, tformat); - if (!texture) + d3d->texture = createtext (d3d, w, h, d3d->tformat); + if (!d3d->texture) return 0; - write_log (_T("%s: %d*%d main texture, depth %d\n"), D3DHEAD, w, h, t_depth); - if (psActive) { + write_log (_T("%s: %d*%d main texture, depth %d\n"), D3DHEAD, w, h, d3d->t_depth); + if (d3d->psActive) { for (int i = 0; i < MAX_SHADERS; i++) { int w2, h2; - int type = shaders[i].type; + int type = d3d->shaders[i].type; if (type == SHADERTYPE_BEFORE) { - w2 = shaders[i].worktex_width; - h2 = shaders[i].worktex_height; - if (!allocextratextures (&shaders[i], w, h)) + w2 = d3d->shaders[i].worktex_width; + h2 = d3d->shaders[i].worktex_height; + if (!allocextratextures (d3d, &d3d->shaders[i], w, h)) return 0; } else if (type == SHADERTYPE_MIDDLE) { - w2 = shaders[i].worktex_width; - h2 = shaders[i].worktex_height; + w2 = d3d->shaders[i].worktex_width; + h2 = d3d->shaders[i].worktex_height; } else { - w2 = window_w; - h2 = window_h; + w2 = d3d->window_w; + h2 = d3d->window_h; } if (type == SHADERTYPE_BEFORE || type == SHADERTYPE_AFTER || type == SHADERTYPE_MIDDLE) { D3DLOCKED_BOX lockedBox; - if (FAILED (hr = d3ddev->CreateVolumeTexture (256, 16, 256, 1, D3DUSAGE_DYNAMIC, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &shaders[i].lpHq2xLookupTexture, NULL))) { + if (FAILED (hr = d3d->d3ddev->CreateVolumeTexture (256, 16, 256, 1, D3DUSAGE_DYNAMIC, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &d3d->shaders[i].lpHq2xLookupTexture, NULL))) { write_log (_T("%s: Failed to create volume texture: %s:%d\n"), D3DHEAD, D3D_ErrorString (hr), i); return 0; } - if (FAILED (hr = shaders[i].lpHq2xLookupTexture->LockBox (0, &lockedBox, NULL, 0))) { + if (FAILED (hr = d3d->shaders[i].lpHq2xLookupTexture->LockBox (0, &lockedBox, NULL, 0))) { write_log (_T("%s: Failed to lock box of volume texture: %s:%d\n"), D3DHEAD, D3D_ErrorString (hr), i); return 0; } write_log (_T("HQ2X texture (%dx%d) (%dx%d):%d\n"), w2, h2, w, h, i); BuildHq2xLookupTexture (w2, h2, w, h, (unsigned char*)lockedBox.pBits); - shaders[i].lpHq2xLookupTexture->UnlockBox (0); + d3d->shaders[i].lpHq2xLookupTexture->UnlockBox (0); } } } return 1; } -static int createtexture (int ow, int oh, int win_w, int win_h) +static int createtexture (struct d3dstruct *d3d, int ow, int oh, int win_w, int win_h) { HRESULT hr; bool haveafter = false; int zw, zh; - if (ow > win_w * dmultx && oh > win_h * dmultx) { + if (ow > win_w * d3d->dmultx && oh > win_h * d3d->dmultx) { zw = ow; zh = oh; } else { - zw = win_w * dmultx; - zh = win_h * dmultx; + zw = win_w * d3d->dmultx; + zh = win_h * d3d->dmultx; } for (int i = 0; i < MAX_SHADERS; i++) { - if (shaders[i].type == SHADERTYPE_BEFORE || shaders[i].type == SHADERTYPE_AFTER || shaders[i].type == SHADERTYPE_MIDDLE) { + if (d3d->shaders[i].type == SHADERTYPE_BEFORE || d3d->shaders[i].type == SHADERTYPE_AFTER || d3d->shaders[i].type == SHADERTYPE_MIDDLE) { int w2, h2, w, h; - if (shaders[i].type == SHADERTYPE_AFTER) { + if (d3d->shaders[i].type == SHADERTYPE_AFTER) { w2 = zw; h2 = zh; w = zw; h = zh; haveafter = true; - if (!allocextratextures (&shaders[i], window_w, window_h)) + if (!allocextratextures (d3d, &d3d->shaders[i], d3d->window_w, d3d->window_h)) return 0; - } else if (shaders[i].type == SHADERTYPE_MIDDLE) { + } else if (d3d->shaders[i].type == SHADERTYPE_MIDDLE) { // worktex_width = 800 // extratex = amiga res w2 = zw; h2 = zh; w = zw; h = zh; - if (!allocextratextures (&shaders[i], ow, oh)) + if (!allocextratextures (d3d, &d3d->shaders[i], ow, oh)) return 0; } else { w2 = ow; @@ -1289,28 +1295,28 @@ static int createtexture (int ow, int oh, int win_w, int win_h) w = ow; h = oh; } - shaders[i].targettex_width = w2; - shaders[i].targettex_height = h2; - if (FAILED (hr = d3ddev->CreateTexture (w2, h2, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &shaders[i].lpTempTexture, NULL))) { - write_log (_T("%s: Failed to create working texture1: %s:%d:%d\n"), D3DHEAD, D3D_ErrorString (hr), i, shaders[i].type); + d3d->shaders[i].targettex_width = w2; + d3d->shaders[i].targettex_height = h2; + if (FAILED (hr = d3d->d3ddev->CreateTexture (w2, h2, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &d3d->shaders[i].lpTempTexture, NULL))) { + write_log (_T("%s: Failed to create working texture1: %s:%d:%d\n"), D3DHEAD, D3D_ErrorString (hr), i, d3d->shaders[i].type); return 0; } - write_log (_T("%s: %d*%d temp texture:%d:%d\n"), D3DHEAD, w2, h2, i, shaders[i].type); - shaders[i].worktex_width = w; - shaders[i].worktex_height = h; + write_log (_T("%s: %d*%d temp texture:%d:%d\n"), D3DHEAD, w2, h2, i, d3d->shaders[i].type); + d3d->shaders[i].worktex_width = w; + d3d->shaders[i].worktex_height = h; } } if (haveafter) { - if (FAILED (hr = d3ddev->CreateTexture (window_w, window_h, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &lpPostTempTexture, NULL))) { + if (FAILED (hr = d3d->d3ddev->CreateTexture (d3d->window_w, d3d->window_h, 1, D3DUSAGE_RENDERTARGET, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, &d3d->lpPostTempTexture, NULL))) { write_log (_T("%s: Failed to create temp texture: %s\n"), D3DHEAD, D3D_ErrorString (hr)); return 0; } - write_log (_T("%s: %d*%d after texture\n"), D3DHEAD, window_w, window_h); + write_log (_T("%s: %d*%d after texture\n"), D3DHEAD, d3d->window_w, d3d->window_h); } return 1; } -static void updateleds (void) +static void updateleds (struct d3dstruct *d3d) { D3DLOCKED_RECT locked; HRESULT hr; @@ -1326,51 +1332,55 @@ static void updateleds (void) } done = 1; } - hr = ledtexture->LockRect (0, &locked, NULL, D3DLOCK_DISCARD); + hr = d3d->ledtexture->LockRect (0, &locked, NULL, D3DLOCK_DISCARD); if (FAILED (hr)) { write_log (_T("%d: SL LockRect failed: %s\n"), D3DHEAD, D3D_ErrorString (hr)); return; } - for (int y = 0; y < TD_TOTAL_HEIGHT * statusbar_vx; y++) { + for (int y = 0; y < TD_TOTAL_HEIGHT * d3d->statusbar_vx; y++) { uae_u8 *buf = (uae_u8*)locked.pBits + y * locked.Pitch; - statusline_single_erase(buf, 32 / 8, y, ledwidth * statusbar_hx); + statusline_single_erase(buf, 32 / 8, y, d3d->ledwidth * d3d->statusbar_hx); } - statusline_render((uae_u8*)locked.pBits, 32 / 8, locked.Pitch, ledwidth, ledheight, rc, gc, bc, a); + statusline_render((uae_u8*)locked.pBits, 32 / 8, locked.Pitch, d3d->ledwidth, d3d->ledheight, rc, gc, bc, a); int y = 0; - for (int yy = 0; yy < statusbar_vx * TD_TOTAL_HEIGHT; yy++) { + for (int yy = 0; yy < d3d->statusbar_vx * TD_TOTAL_HEIGHT; yy++) { uae_u8 *buf = (uae_u8*)locked.pBits + yy * locked.Pitch; - draw_status_line_single (buf, 32 / 8, y, ledwidth, rc, gc, bc, a); - if ((yy % statusbar_vx) == 0) + draw_status_line_single (buf, 32 / 8, y, d3d->ledwidth, rc, gc, bc, a); + if ((yy % d3d->statusbar_vx) == 0) y++; } - ledtexture->UnlockRect (0); + d3d->ledtexture->UnlockRect (0); } -static int createledtexture (void) +static int createledtexture (struct d3dstruct *d3d) { - ledwidth = window_w; - ledheight = TD_TOTAL_HEIGHT; - ledtexture = createtext (ledwidth * statusbar_hx, ledheight * statusbar_vx, D3DFMT_A8R8G8B8); - if (!ledtexture) + d3d->ledwidth = d3d->window_w; + d3d->ledheight = TD_TOTAL_HEIGHT; + if (d3d->statusbar_hx < 1) + d3d->statusbar_hx = 1; + if (d3d->statusbar_vx < 1) + d3d->statusbar_vx = 1; + d3d->ledtexture = createtext (d3d, d3d->ledwidth * d3d->statusbar_hx, d3d->ledheight * d3d->statusbar_vx, D3DFMT_A8R8G8B8); + if (!d3d->ledtexture) return 0; return 1; } -static int createsltexture (void) +static int createsltexture (struct d3dstruct *d3d) { - sltexture = createtext (required_sl_texture_w, required_sl_texture_h, t_depth < 32 ? D3DFMT_A4R4G4B4 : D3DFMT_A8R8G8B8); - if (!sltexture) + d3d->sltexture = createtext (d3d, d3d->required_sl_texture_w, d3d->required_sl_texture_h, d3d->t_depth < 32 ? D3DFMT_A4R4G4B4 : D3DFMT_A8R8G8B8); + if (!d3d->sltexture) return 0; - write_log (_T("%s: SL %d*%d texture allocated\n"), D3DHEAD, required_sl_texture_w, required_sl_texture_h); - maskmult_x = 1.0f; - maskmult_y = 1.0f; + write_log (_T("%s: SL %d*%d texture allocated\n"), D3DHEAD, d3d->required_sl_texture_w, d3d->required_sl_texture_h); + d3d->maskmult_x = 1.0f; + d3d->maskmult_y = 1.0f; return 1; } -static void createscanlines (int force) +static void createscanlines (struct d3dstruct *d3d, int force) { HRESULT hr; D3DLOCKED_RECT locked; @@ -1383,7 +1393,7 @@ static void createscanlines (int force) if (osl1 == filterd3d->gfx_filter_scanlines && osl3 == filterd3d->gfx_filter_scanlinelevel && osl2 == filterd3d->gfx_filter_scanlineratio && !force) return; - bpp = t_depth < 32 ? 2 : 4; + bpp = d3d->t_depth < 32 ? 2 : 4; osl1 = filterd3d->gfx_filter_scanlines; osl3 = filterd3d->gfx_filter_scanlinelevel; osl2 = filterd3d->gfx_filter_scanlineratio; @@ -1399,24 +1409,24 @@ static void createscanlines (int force) if (l1 + l2 <= 0) return; - if (!sltexture) { + if (!d3d->sltexture) { if (osl1 == 0 && osl3 == 0) return; - if (!createsltexture ()) + if (!createsltexture (d3d)) return; } - hr = sltexture->LockRect (0, &locked, NULL, 0); + hr = d3d->sltexture->LockRect (0, &locked, NULL, 0); if (FAILED (hr)) { write_log (_T("%s: SL LockRect failed: %s\n"), D3DHEAD, D3D_ErrorString (hr)); return; } sld = (uae_u8*)locked.pBits; - for (y = 0; y < required_sl_texture_h; y++) - memset (sld + y * locked.Pitch, 0, required_sl_texture_w * bpp); - for (y = 1; y < required_sl_texture_h; y += l1 + l2) { - for (yy = 0; yy < l2 && y + yy < required_sl_texture_h; yy++) { - for (x = 0; x < required_sl_texture_w; x++) { + for (y = 0; y < d3d->required_sl_texture_h; y++) + memset (sld + y * locked.Pitch, 0, d3d->required_sl_texture_w * bpp); + for (y = 1; y < d3d->required_sl_texture_h; y += l1 + l2) { + for (yy = 0; yy < l2 && y + yy < d3d->required_sl_texture_h; yy++) { + for (x = 0; x < d3d->required_sl_texture_w; x++) { uae_u8 sll = sl42; p = &sld[(y + yy) * locked.Pitch + (x * bpp)]; if (bpp < 4) { @@ -1435,7 +1445,7 @@ static void createscanlines (int force) } } } - sltexture->UnlockRect (0); + d3d->sltexture->UnlockRect (0); } static int findedge (D3DLOCKED_RECT *lock, int w, int h, int dx, int dy) @@ -1465,7 +1475,7 @@ static int findedge (D3DLOCKED_RECT *lock, int w, int h, int dx, int dy) return y; } -static int createmask2texture (const TCHAR *filename) +static int createmask2texture (struct d3dstruct *d3d, const TCHAR *filename) { struct zfile *zf; int size; @@ -1475,9 +1485,9 @@ static int createmask2texture (const TCHAR *filename) D3DXIMAGE_INFO dinfo; TCHAR tmp[MAX_DPATH]; - if (mask2texture) - mask2texture->Release(); - mask2texture = NULL; + if (d3d->mask2texture) + d3d->mask2texture->Release(); + d3d->mask2texture = NULL; if (filename[0] == 0 || WIN32GFX_IsPicassoScreen ()) return 0; @@ -1510,11 +1520,11 @@ static int createmask2texture (const TCHAR *filename) s2--; } _tcscpy (tmp2, s); - _stprintf (s, _T("_%dx%d%s"), window_w, window_h, tmp2); + _stprintf (s, _T("_%dx%d%s"), d3d->window_w, d3d->window_h, tmp2); zf = zfile_fopen (tmp3, _T("rb"), ZFD_NORMAL); if (zf) break; - float aspect = (float)window_w / window_h; + float aspect = (float)d3d->window_w / d3d->window_h; int ax = -1, ay = -1; if (abs (aspect - 16.0 / 10.0) <= 0.1) ax = 16, ay = 10; @@ -1541,7 +1551,7 @@ static int createmask2texture (const TCHAR *filename) buf = xmalloc (uae_u8, size); zfile_fread (buf, size, 1, zf); zfile_fclose (zf); - hr = D3DXCreateTextureFromFileInMemoryEx (d3ddev, buf, size, + hr = D3DXCreateTextureFromFileInMemoryEx (d3d->d3ddev, buf, size, D3DX_DEFAULT_NONPOW2, D3DX_DEFAULT_NONPOW2, 1, D3DUSAGE_DYNAMIC, D3DFMT_A8R8G8B8, D3DPOOL_DEFAULT, D3DX_FILTER_NONE, D3DX_FILTER_NONE, 0, &dinfo, NULL, &tx); xfree (buf); @@ -1549,32 +1559,32 @@ static int createmask2texture (const TCHAR *filename) write_log (_T("%s: overlay texture load failed: %s\n"), D3DHEAD, D3D_ErrorString (hr)); goto end; } - mask2texture_w = dinfo.Width; - mask2texture_h = dinfo.Height; - mask2texture = tx; - mask2rect.left = 0; - mask2rect.top = 0; - mask2rect.right = mask2texture_w; - mask2rect.bottom = mask2texture_h; + d3d->mask2texture_w = dinfo.Width; + d3d->mask2texture_h = dinfo.Height; + d3d->mask2texture = tx; + d3d->mask2rect.left = 0; + d3d->mask2rect.top = 0; + d3d->mask2rect.right = d3d->mask2texture_w; + d3d->mask2rect.bottom = d3d->mask2texture_h; D3DLOCKED_RECT lock; - if (SUCCEEDED (hr = mask2texture->LockRect (0, &lock, NULL, 0))) { - mask2rect.left = findedge (&lock, mask2texture_w, mask2texture_h, -1, 0); - mask2rect.right = findedge (&lock, mask2texture_w, mask2texture_h, 1, 0); - mask2rect.top = findedge (&lock, mask2texture_w, mask2texture_h, 0, -1); - mask2rect.bottom = findedge (&lock, mask2texture_w, mask2texture_h, 0, 1); - mask2texture->UnlockRect (0); - } - if (mask2rect.left >= mask2texture_w / 2 || mask2rect.top >= mask2texture_h / 2 || - mask2rect.right <= mask2texture_w / 2 || mask2rect.bottom <= mask2texture_h / 2) { - mask2rect.left = 0; - mask2rect.top = 0; - mask2rect.right = mask2texture_w; - mask2rect.bottom = mask2texture_h; - } - mask2texture_multx = (float)window_w / mask2texture_w; - mask2texture_multy = (float)window_h / mask2texture_h; - mask2texture_offsetw = 0; + if (SUCCEEDED (hr = d3d->mask2texture->LockRect (0, &lock, NULL, 0))) { + d3d->mask2rect.left = findedge (&lock, d3d->mask2texture_w, d3d->mask2texture_h, -1, 0); + d3d->mask2rect.right = findedge (&lock, d3d->mask2texture_w, d3d->mask2texture_h, 1, 0); + d3d->mask2rect.top = findedge (&lock, d3d->mask2texture_w, d3d->mask2texture_h, 0, -1); + d3d->mask2rect.bottom = findedge (&lock, d3d->mask2texture_w, d3d->mask2texture_h, 0, 1); + d3d->mask2texture->UnlockRect (0); + } + if (d3d->mask2rect.left >= d3d->mask2texture_w / 2 || d3d->mask2rect.top >= d3d->mask2texture_h / 2 || + d3d->mask2rect.right <= d3d->mask2texture_w / 2 || d3d->mask2rect.bottom <= d3d->mask2texture_h / 2) { + d3d->mask2rect.left = 0; + d3d->mask2rect.top = 0; + d3d->mask2rect.right = d3d->mask2texture_w; + d3d->mask2rect.bottom = d3d->mask2texture_h; + } + d3d->mask2texture_multx = (float)d3d->window_w / d3d->mask2texture_w; + d3d->mask2texture_multy = (float)d3d->window_h / d3d->mask2texture_h; + d3d->mask2texture_offsetw = 0; if (isfullscreen () > 0) { struct MultiDisplay *md = getdisplay (&currprefs); @@ -1582,48 +1592,48 @@ static int createmask2texture (const TCHAR *filename) float deskh = md->rect.bottom - md->rect.top; //deskw = 800; deskh = 600; float dstratio = deskw / deskh; - float srcratio = mask2texture_w / mask2texture_h; - mask2texture_multx *= srcratio / dstratio; + float srcratio = d3d->mask2texture_w / d3d->mask2texture_h; + d3d->mask2texture_multx *= srcratio / dstratio; } else { - mask2texture_multx = mask2texture_multy; + d3d->mask2texture_multx = d3d->mask2texture_multy; } - mask2texture_wh = window_h; - mask2texture_ww = mask2texture_w * mask2texture_multx; + d3d->mask2texture_wh = d3d->window_h; + d3d->mask2texture_ww = d3d->mask2texture_w * d3d->mask2texture_multx; - mask2texture_offsetw = (window_w - mask2texture_ww) / 2; + d3d->mask2texture_offsetw = (d3d->window_w - d3d->mask2texture_ww) / 2; - if (mask2texture_offsetw > 0) - blanktexture = createtext (mask2texture_offsetw + 1, window_h, D3DFMT_X8R8G8B8); + if (d3d->mask2texture_offsetw > 0) + d3d->blanktexture = createtext (d3d, d3d->mask2texture_offsetw + 1, d3d->window_h, D3DFMT_X8R8G8B8); - float xmult = mask2texture_multx; - float ymult = mask2texture_multy; + float xmult = d3d->mask2texture_multx; + float ymult = d3d->mask2texture_multy; - mask2rect.left *= xmult; - mask2rect.right *= xmult; - mask2rect.top *= ymult; - mask2rect.bottom *= ymult; - mask2texture_wwx = mask2texture_w * xmult; - if (mask2texture_wwx > window_w) - mask2texture_wwx = window_w; - if (mask2texture_wwx < mask2rect.right - mask2rect.left) - mask2texture_wwx = mask2rect.right - mask2rect.left; - if (mask2texture_wwx > mask2texture_ww) - mask2texture_wwx = mask2texture_ww; + d3d->mask2rect.left *= xmult; + d3d->mask2rect.right *= xmult; + d3d->mask2rect.top *= ymult; + d3d->mask2rect.bottom *= ymult; + d3d->mask2texture_wwx = d3d->mask2texture_w * xmult; + if (d3d->mask2texture_wwx > d3d->window_w) + d3d->mask2texture_wwx = d3d->window_w; + if (d3d->mask2texture_wwx < d3d->mask2rect.right - d3d->mask2rect.left) + d3d->mask2texture_wwx = d3d->mask2rect.right - d3d->mask2rect.left; + if (d3d->mask2texture_wwx > d3d->mask2texture_ww) + d3d->mask2texture_wwx = d3d->mask2texture_ww; - mask2texture_minusx = - ((window_w - mask2rect.right) + mask2rect.left); - if (mask2texture_offsetw > 0) - mask2texture_minusx += mask2texture_offsetw * xmult; + d3d->mask2texture_minusx = - ((d3d->window_w - d3d->mask2rect.right) + d3d->mask2rect.left); + if (d3d->mask2texture_offsetw > 0) + d3d->mask2texture_minusx += d3d->mask2texture_offsetw * xmult; - mask2texture_minusy = -(window_h - (mask2rect.bottom - mask2rect.top)); + d3d->mask2texture_minusy = -(d3d->window_h - (d3d->mask2rect.bottom - d3d->mask2rect.top)); - mask2texture_hhx = mask2texture_h * ymult; + d3d->mask2texture_hhx = d3d->mask2texture_h * ymult; write_log (_T("%s: overlay '%s' %.0f*%.0f (%d*%d - %d*%d) (%d*%d)\n"), - D3DHEAD, tmp, mask2texture_w, mask2texture_h, - mask2rect.left, mask2rect.top, mask2rect.right, mask2rect.bottom, - mask2rect.right - mask2rect.left, mask2rect.bottom - mask2rect.top); + D3DHEAD, tmp, d3d->mask2texture_w, d3d->mask2texture_h, + d3d->mask2rect.left, d3d->mask2rect.top, d3d->mask2rect.right, d3d->mask2rect.bottom, + d3d->mask2rect.right - d3d->mask2rect.left, d3d->mask2rect.bottom - d3d->mask2rect.top); return 1; end: @@ -1632,7 +1642,7 @@ end: return 0; } -static int createmasktexture (const TCHAR *filename, struct shaderdata *sd) +static int createmasktexture (struct d3dstruct *d3d, const TCHAR *filename, struct shaderdata *sd) { struct zfile *zf; int size; @@ -1644,7 +1654,7 @@ static int createmasktexture (const TCHAR *filename, struct shaderdata *sd) D3DXIMAGE_INFO dinfo; TCHAR tmp[MAX_DPATH]; int maskwidth, maskheight; - int idx = sd - &shaders[0]; + int idx = sd - &d3d->shaders[0]; if (filename[0] == 0) return 0; @@ -1663,7 +1673,7 @@ static int createmasktexture (const TCHAR *filename, struct shaderdata *sd) buf = xmalloc (uae_u8, size); zfile_fread (buf, size, 1, zf); zfile_fclose (zf); - hr = D3DXCreateTextureFromFileInMemoryEx (d3ddev, buf, size, + hr = D3DXCreateTextureFromFileInMemoryEx (d3d->d3ddev, buf, size, D3DX_DEFAULT_NONPOW2, D3DX_DEFAULT_NONPOW2, 1, D3DUSAGE_DYNAMIC, D3DFMT_X8R8G8B8, D3DPOOL_DEFAULT, D3DX_FILTER_NONE, D3DX_FILTER_NONE, 0, &dinfo, NULL, &tx); xfree (buf); @@ -1691,13 +1701,13 @@ static int createmasktexture (const TCHAR *filename, struct shaderdata *sd) } else { #endif // both must be divisible by mask size - maskwidth = ((window_w + sd->masktexture_w - 1) / sd->masktexture_w) * sd->masktexture_w; - maskheight = ((window_h + sd->masktexture_h - 1) / sd->masktexture_h) * sd->masktexture_h; + maskwidth = ((d3d->window_w + sd->masktexture_w - 1) / sd->masktexture_w) * sd->masktexture_w; + maskheight = ((d3d->window_h + sd->masktexture_h - 1) / sd->masktexture_h) * sd->masktexture_h; #if 0 } #endif if (tx) { - sd->masktexture = createtext (maskwidth, maskheight, D3DFMT_X8R8G8B8); + sd->masktexture = createtext (d3d, maskwidth, maskheight, D3DFMT_X8R8G8B8); if (FAILED (hr)) { write_log (_T("%s: mask texture creation failed: %s:%d\n"), D3DHEAD, D3D_ErrorString (hr), idx); goto end; @@ -1739,8 +1749,8 @@ static int createmasktexture (const TCHAR *filename, struct shaderdata *sd) sd->masktexture_h = maskdesc.Height; } write_log (_T("%s: mask %d*%d (%d*%d) %d*%d ('%s':%d) texture allocated\n"), D3DHEAD, sd->masktexture_w, sd->masktexture_h, txdesc.Width, txdesc.Height, maskdesc.Width, maskdesc.Height, filename, idx); - maskmult_x = (float)window_w / sd->masktexture_w; - maskmult_y = (float)window_h / sd->masktexture_h; + d3d->maskmult_x = (float)d3d->window_w / sd->masktexture_w; + d3d->maskmult_y = (float)d3d->window_h / sd->masktexture_h; return 1; end: @@ -1754,20 +1764,21 @@ end: bool getscalerect (float *mx, float *my, float *sx, float *sy) { - if (!mask2texture) + struct d3dstruct *d3d = &d3ddata[0]; + if (!d3d->mask2texture) return false; - float mw = mask2rect.right - mask2rect.left; - float mh = mask2rect.bottom - mask2rect.top; + float mw = d3d->mask2rect.right - d3d->mask2rect.left; + float mh = d3d->mask2rect.bottom - d3d->mask2rect.top; float mxt = (float)mw / gfxvidinfo.outbuffer->inwidth2; float myt = (float)mh / gfxvidinfo.outbuffer->inheight2; - *mx = mask2texture_minusx / mxt; - *my = mask2texture_minusy / myt; + *mx = d3d->mask2texture_minusx / mxt; + *my = d3d->mask2texture_minusy / myt; - *sx = -((mask2texture_ww - mask2rect.right) - (mask2rect.left)) / 2; - *sy = -((mask2texture_wh - mask2rect.bottom) - (mask2rect.top)) / 2; + *sx = -((d3d->mask2texture_ww - d3d->mask2rect.right) - (d3d->mask2rect.left)) / 2; + *sy = -((d3d->mask2texture_wh - d3d->mask2rect.bottom) - (d3d->mask2rect.top)) / 2; *sx /= mxt; *sy /= myt; @@ -1775,7 +1786,7 @@ bool getscalerect (float *mx, float *my, float *sx, float *sy) return true; } -static void setupscenecoords (void) +static void setupscenecoords (struct d3dstruct *d3d) { RECT sr, dr, zr; float w, h; @@ -1784,7 +1795,7 @@ static void setupscenecoords (void) //write_log (_T("%dx%d %dx%d %dx%d\n"), tin_w, tin_h, tin_w, tin_h, window_w, window_h); - getfilterrect2 (&dr, &sr, &zr, window_w, window_h, tin_w / dmult, tin_h / dmult, dmult, tin_w, tin_h); + getfilterrect2 (&dr, &sr, &zr, d3d->window_w, d3d->window_h, d3d->tin_w / d3d->dmult, d3d->tin_h / d3d->dmult, d3d->dmult, d3d->tin_w, d3d->tin_h); if (memcmp (&sr, &sr2, sizeof RECT) || memcmp (&dr, &dr2, sizeof RECT) || memcmp (&zr, &zr2, sizeof RECT)) { write_log (_T("POS (%d %d %d %d) - (%d %d %d %d)[%d,%d] (%d %d)\n"), @@ -1801,50 +1812,50 @@ static void setupscenecoords (void) w = sr.right - sr.left; h = sr.bottom - sr.top; - fakesize.x = w; - fakesize.y = h; - fakesize.w = 1; - fakesize.z = 1; + d3d->fakesize.x = w; + d3d->fakesize.y = h; + d3d->fakesize.w = 1; + d3d->fakesize.z = 1; - MatrixOrthoOffCenterLH (&m_matProj_out, 0, w + 0.05f, 0, h + 0.05f, 0.0f, 1.0f); + MatrixOrthoOffCenterLH (&d3d->m_matProj_out, 0, w + 0.05f, 0, h + 0.05f, 0.0f, 1.0f); float tx, ty; float sw, sh; - if (0 && mask2texture) { + if (0 && d3d->mask2texture) { - float mw = mask2rect.right - mask2rect.left; - float mh = mask2rect.bottom - mask2rect.top; + float mw = d3d->mask2rect.right - d3d->mask2rect.left; + float mh = d3d->mask2rect.bottom - d3d->mask2rect.top; - tx = -0.5f + dw * tin_w / mw / 2; - ty = +0.5f + dh * tin_h / mh / 2; + tx = -0.5f + dw * d3d->tin_w / mw / 2; + ty = +0.5f + dh * d3d->tin_h / mh / 2; float xshift = -zr.left; float yshift = -zr.top; - sw = dw * tin_w / gfxvidinfo.outbuffer->inwidth2; - sw *= mw / window_w; + sw = dw * d3d->tin_w / gfxvidinfo.outbuffer->inwidth2; + sw *= mw / d3d->window_w; - tx = -0.5f + window_w / 2; + tx = -0.5f + d3d->window_w / 2; - sh = dh * tin_h / gfxvidinfo.outbuffer->inheight2; - sh *= mh / window_h; + sh = dh * d3d->tin_h / gfxvidinfo.outbuffer->inheight2; + sh *= mh / d3d->window_h; - ty = +0.5f + window_h / 2; + ty = +0.5f + d3d->window_h / 2; tx += xshift; ty += yshift; } else { - tx = -0.5f + dw * tin_w / window_w / 2; - ty = +0.5f + dh * tin_h / window_h / 2; + tx = -0.5f + dw * d3d->tin_w / d3d->window_w / 2; + ty = +0.5f + dh * d3d->tin_h / d3d->window_h / 2; float xshift = - zr.left - sr.left; // - (tin_w - 2 * zr.left - w), - float yshift = + zr.top + sr.top - (tin_h - h); + float yshift = + zr.top + sr.top - (d3d->tin_h - h); - sw = dw * tin_w / window_w; - sh = dh * tin_h / window_h; + sw = dw * d3d->tin_w / d3d->window_w; + sh = dh * d3d->tin_h / d3d->window_h; //sw -= 0.5f; //sh += 0.5f; @@ -1854,53 +1865,54 @@ static void setupscenecoords (void) } - MatrixTranslation (&m_matView_out, tx, ty, 1.0f); + MatrixTranslation (&d3d->m_matView_out, tx, ty, 1.0f); - MatrixScaling (&m_matWorld_out, sw + 0.5f / sw, sh + 0.5f / sh, 1.0f); + MatrixScaling (&d3d->m_matWorld_out, sw + 0.5f / sw, sh + 0.5f / sh, 1.0f); - cursor_offset_x = -zr.left; - cursor_offset_y = -zr.top; + d3d->cursor_offset_x = -zr.left; + d3d->cursor_offset_y = -zr.top; //write_log (_T("%.1fx%.1f %.1fx%.1f %.1fx%.1f\n"), dw, dh, w, h, sw, sh); // ratio between Amiga texture and overlay mask texture - float sw2 = dw * tin_w / window_w; - float sh2 = dh * tin_h / window_h; + float sw2 = dw * d3d->tin_w / d3d->window_w; + float sh2 = dh * d3d->tin_h / d3d->window_h; //sw2 -= 0.5f; //sh2 += 0.5f; - maskmult.x = sw2 * maskmult_x / w; - maskmult.y = sh2 * maskmult_y / h; + d3d->maskmult.x = sw2 * d3d->maskmult_x / w; + d3d->maskmult.y = sh2 * d3d->maskmult_y / h; - maskshift.x = 1.0f / maskmult_x; - maskshift.y = 1.0f / maskmult_y; + d3d->maskshift.x = 1.0f / d3d->maskmult_x; + d3d->maskshift.y = 1.0f / d3d->maskmult_y; D3DXMATRIXA16 tmpmatrix; - D3DXMatrixMultiply (&tmpmatrix, &m_matWorld_out, &m_matView_out); - D3DXMatrixMultiply (&postproj, &tmpmatrix, &m_matProj_out); + D3DXMatrixMultiply (&tmpmatrix, &d3d->m_matWorld_out, &d3d->m_matView_out); + D3DXMatrixMultiply (&d3d->postproj, &tmpmatrix, &d3d->m_matProj_out); } uae_u8 *getfilterbuffer3d (struct vidbuffer *vb, int *widthp, int *heightp, int *pitch, int *depth) { + struct d3dstruct *d3d = &d3ddata[0]; RECT dr, sr, zr; uae_u8 *p; int w, h; - *depth = t_depth; - getfilterrect2 (&dr, &sr, &zr, window_w, window_h, tin_w / dmult, tin_h / dmult, dmult, tin_w, tin_h); + *depth = d3d->t_depth; + getfilterrect2 (&dr, &sr, &zr, d3d->window_w, d3d->window_h, d3d->tin_w / d3d->dmult, d3d->tin_h / d3d->dmult, d3d->dmult, d3d->tin_w, d3d->tin_h); w = sr.right - sr.left; h = sr.bottom - sr.top; p = vb->bufmem; if (pitch) *pitch = vb->rowbytes; - p += (zr.top - h / 2) * vb->rowbytes + (zr.left - w / 2) * t_depth / 8; + p += (zr.top - h / 2) * vb->rowbytes + (zr.left - w / 2) * d3d->t_depth / 8; *widthp = w; *heightp = h; return p; } -static void createvertex (void) +static void createvertex (struct d3dstruct *d3d) { HRESULT hr; struct TLVERTEX *vertices; @@ -1908,7 +1920,7 @@ static void createvertex (void) sizex = 1.0f; sizey = 1.0f; - if (FAILED (hr = vertexBuffer->Lock (0, 0, (void**)&vertices, 0))) { + if (FAILED (hr = d3d->vertexBuffer->Lock (0, 0, (void**)&vertices, 0))) { write_log (_T("%s: Vertexbuffer lock failed: %s\n"), D3DHEAD, D3D_ErrorString (hr)); return; } @@ -1939,62 +1951,62 @@ static void createvertex (void) vertices[7].position.x = 1.0f; vertices[7].position.y = 1.0f; vertices[7].diffuse = 0xFFFFFF00; vertices[7].texcoord.x = 1.0f; vertices[7].texcoord.y = 0.0f; - if (FAILED(hr = vertexBuffer->Unlock ())) + if (FAILED(hr = d3d->vertexBuffer->Unlock ())) write_log (_T("%s: Vertexbuffer unlock failed: %s\n"), D3DHEAD, D3D_ErrorString (hr)); } -static void settransform_pre (struct shaderdata *s) +static void settransform_pre (struct d3dstruct *d3d, struct shaderdata *s) { // Projection is (0,0,0) -> (1,1,1) - MatrixOrthoOffCenterLH (&m_matProj, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f); + MatrixOrthoOffCenterLH (&d3d->m_matProj, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f); // Align texels with pixels - MatrixTranslation (&m_matView, -0.5f / tout_w, 0.5f / tout_h, 0.0f); + MatrixTranslation (&d3d->m_matView, -0.5f / d3d->tout_w, 0.5f / d3d->tout_h, 0.0f); // Identity for world - D3DXMatrixIdentity (&m_matWorld); + D3DXMatrixIdentity (&d3d->m_matWorld); } -static void settransform (struct shaderdata *s) +static void settransform (struct d3dstruct *d3d, struct shaderdata *s) { // Projection is (0,0,0) -> (1,1,1) - MatrixOrthoOffCenterLH (&m_matPreProj, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f); + MatrixOrthoOffCenterLH (&d3d->m_matPreProj, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f); // Align texels with pixels - MatrixTranslation (&m_matPreView, -0.5f / tout_w, 0.5f / tout_h, 0.0f); + MatrixTranslation (&d3d->m_matPreView, -0.5f / d3d->tout_w, 0.5f / d3d->tout_h, 0.0f); // Identity for world - D3DXMatrixIdentity (&m_matPreWorld); + D3DXMatrixIdentity (&d3d->m_matPreWorld); if (s) - psEffect_SetMatrices (&m_matProj, &m_matView, &m_matWorld, s); + psEffect_SetMatrices (&d3d->m_matProj, &d3d->m_matView, &d3d->m_matWorld, s); - MatrixOrthoOffCenterLH (&m_matProj2, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f); + MatrixOrthoOffCenterLH (&d3d->m_matProj2, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f); - MatrixTranslation (&m_matView2, 0.5f - 0.5f / tout_w, 0.5f + 0.5f / tout_h, 0.0f); + MatrixTranslation (&d3d->m_matView2, 0.5f - 0.5f / d3d->tout_w, 0.5f + 0.5f / d3d->tout_h, 0.0f); - D3DXMatrixIdentity (&m_matWorld2); + D3DXMatrixIdentity (&d3d->m_matWorld2); } -static void settransform2 (struct shaderdata *s) +static void settransform2 (struct d3dstruct *d3d, struct shaderdata *s) { // Projection is (0,0,0) -> (1,1,1) - MatrixOrthoOffCenterLH (&m_matPreProj, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f); + MatrixOrthoOffCenterLH (&d3d->m_matPreProj, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f); // Align texels with pixels - MatrixTranslation (&m_matPreView, -0.5f / window_w, 0.5f / window_h, 0.0f); + MatrixTranslation (&d3d->m_matPreView, -0.5f / d3d->window_w, 0.5f / d3d->window_h, 0.0f); // Identity for world - D3DXMatrixIdentity (&m_matPreWorld); + D3DXMatrixIdentity (&d3d->m_matPreWorld); - MatrixOrthoOffCenterLH (&m_matProj2, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f); + MatrixOrthoOffCenterLH (&d3d->m_matProj2, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f); - MatrixTranslation (&m_matView2, 0.5f - 0.5f / window_w, 0.5f + 0.5f / window_h, 0.0f); - D3DXMatrixIdentity (&m_matWorld2); + MatrixTranslation (&d3d->m_matView2, 0.5f - 0.5f / d3d->window_w, 0.5f + 0.5f / d3d->window_h, 0.0f); + D3DXMatrixIdentity (&d3d->m_matWorld2); } -static void freetextures (void) +static void freetextures (struct d3dstruct *d3d) { - if (texture) { - texture->Release (); - texture = NULL; + if (d3d->texture) { + d3d->texture->Release (); + d3d->texture = NULL; } for (int i = 0; i < MAX_SHADERS; i++) { - struct shaderdata *s = &shaders[i]; + struct shaderdata *s = &d3d->shaders[i]; if (s->lpTempTexture) { s->lpTempTexture->Release (); s->lpTempTexture = NULL; @@ -2012,217 +2024,218 @@ static void freetextures (void) s->lpHq2xLookupTexture = NULL; } } - if (lpPostTempTexture) { - lpPostTempTexture->Release(); - lpPostTempTexture = NULL; + if (d3d->lpPostTempTexture) { + d3d->lpPostTempTexture->Release(); + d3d->lpPostTempTexture = NULL; } } -static void getswapchain (void) +static void getswapchain (struct d3dstruct *d3d) { - if (!d3dswapchain) { - HRESULT hr = d3ddev->GetSwapChain (0, &d3dswapchain); + if (!d3d->d3dswapchain) { + HRESULT hr = d3d->d3ddev->GetSwapChain (0, &d3d->d3dswapchain); if (FAILED (hr)) { write_log (_T("%s: GetSwapChain() failed, %s\n"), D3DHEAD, D3D_ErrorString (hr)); } } } -static void invalidatedeviceobjects (void) +static void invalidatedeviceobjects (struct d3dstruct *d3d) { - if (filenotificationhandle != NULL) - FindCloseChangeNotification (filenotificationhandle); - filenotificationhandle = NULL; - freetextures (); - if (query) { - query->Release(); - query = NULL; + if (d3d->filenotificationhandle != NULL) + FindCloseChangeNotification (d3d->filenotificationhandle); + d3d->filenotificationhandle = NULL; + freetextures (d3d); + if (d3d->query) { + d3d->query->Release(); + d3d->query = NULL; } - if (sprite) { - sprite->Release (); - sprite = NULL; + if (d3d->sprite) { + d3d->sprite->Release (); + d3d->sprite = NULL; } - if (ledtexture) { - ledtexture->Release (); - ledtexture = NULL; + if (d3d->ledtexture) { + d3d->ledtexture->Release (); + d3d->ledtexture = NULL; } - if (sltexture) { - sltexture->Release (); - sltexture = NULL; + if (d3d->sltexture) { + d3d->sltexture->Release (); + d3d->sltexture = NULL; } - if (mask2texture) { - mask2texture->Release (); - mask2texture = NULL; + if (d3d->mask2texture) { + d3d->mask2texture->Release (); + d3d->mask2texture = NULL; } - if (blanktexture) { - blanktexture->Release (); - blanktexture = NULL; + if (d3d->blanktexture) { + d3d->blanktexture->Release (); + d3d->blanktexture = NULL; } - if (cursorsurfaced3d) { - cursorsurfaced3d->Release (); - cursorsurfaced3d = NULL; + if (d3d->cursorsurfaced3d) { + d3d->cursorsurfaced3d->Release (); + d3d->cursorsurfaced3d = NULL; } for (int i = 0; i < MAX_SHADERS; i++) { - if (shaders[i].pEffect) { - shaders[i].pEffect->Release (); - shaders[i].pEffect = NULL; + if (d3d->shaders[i].pEffect) { + d3d->shaders[i].pEffect->Release (); + d3d->shaders[i].pEffect = NULL; } - if (shaders[i].masktexture) { - shaders[i].masktexture->Release (); - shaders[i].masktexture = NULL; + if (d3d->shaders[i].masktexture) { + d3d->shaders[i].masktexture->Release (); + d3d->shaders[i].masktexture = NULL; } - memset (&shaders[i], 0, sizeof (struct shaderdata)); + memset (&d3d->shaders[i], 0, sizeof (struct shaderdata)); } - postEffect_freeParameters(); - if (d3ddev) - d3ddev->SetStreamSource (0, NULL, 0, 0); - if (vertexBuffer) { - vertexBuffer->Release (); - vertexBuffer = NULL; + postEffect_freeParameters(d3d); + if (d3d->d3ddev) + d3d->d3ddev->SetStreamSource (0, NULL, 0, 0); + if (d3d->vertexBuffer) { + d3d->vertexBuffer->Release (); + d3d->vertexBuffer = NULL; } - if (d3dswapchain) { - d3dswapchain->Release (); - d3dswapchain = NULL; + if (d3d->d3dswapchain) { + d3d->d3dswapchain->Release (); + d3d->d3dswapchain = NULL; } - locked = 0; - maskshift.x = maskshift.y = maskshift.z = maskshift.w = 0; - maskmult.x = maskmult.y = maskmult.z = maskmult.w = 0; + d3d->locked = 0; + d3d->maskshift.x = d3d->maskshift.y = d3d->maskshift.z = d3d->maskshift.w = 0; + d3d->maskmult.x = d3d->maskmult.y = d3d->maskmult.z = d3d->maskmult.w = 0; } -static struct shaderdata *allocshaderslot (int type) +static struct shaderdata *allocshaderslot (struct d3dstruct *d3d, int type) { for (int i = 0; i < MAX_SHADERS; i++) { - if (shaders[i].type == 0) { - shaders[i].type = type; - return &shaders[i]; + if (d3d->shaders[i].type == 0) { + d3d->shaders[i].type = type; + return &d3d->shaders[i]; } } return NULL; } -static int restoredeviceobjects (void) +static int restoredeviceobjects (struct d3dstruct *d3d) { int vbsize; int wasshader = shaderon; HRESULT hr; - invalidatedeviceobjects (); - getswapchain (); + invalidatedeviceobjects (d3d); + getswapchain (d3d); while (shaderon > 0) { - shaders[SHADER_POST].type = SHADERTYPE_POST; - if (!psEffect_LoadEffect (psEnabled ? _T("_winuae.fx") : _T("_winuae_old.fx"), false, &shaders[SHADER_POST], -1)) { + d3d->shaders[SHADER_POST].type = SHADERTYPE_POST; + if (!psEffect_LoadEffect (d3d, d3d->psEnabled ? _T("_winuae.fx") : _T("_winuae_old.fx"), false, &d3d->shaders[SHADER_POST], -1)) { shaderon = 0; break; } for (int i = 0; i < MAX_FILTERSHADERS; i++) { if (filterd3d->gfx_filtershader[i][0]) { - struct shaderdata *s = allocshaderslot (SHADERTYPE_BEFORE); - if (!psEffect_LoadEffect (filterd3d->gfx_filtershader[i], true, s, i)) { + struct shaderdata *s = allocshaderslot (d3d, SHADERTYPE_BEFORE); + if (!psEffect_LoadEffect (d3d, filterd3d->gfx_filtershader[i], true, s, i)) { filterd3d->gfx_filtershader[i][0] = changed_prefs.gf[filterd3didx].gfx_filtershader[i][0] = 0; break; } } if (filterd3d->gfx_filtermask[i][0]) { - struct shaderdata *s = allocshaderslot (SHADERTYPE_MASK_BEFORE); - createmasktexture (filterd3d->gfx_filtermask[i], s); + struct shaderdata *s = allocshaderslot (d3d, SHADERTYPE_MASK_BEFORE); + createmasktexture (d3d, filterd3d->gfx_filtermask[i], s); } } if (filterd3d->gfx_filtershader[2 * MAX_FILTERSHADERS][0]) { - struct shaderdata *s = allocshaderslot (SHADERTYPE_MIDDLE); - if (!psEffect_LoadEffect (filterd3d->gfx_filtershader[2 * MAX_FILTERSHADERS], true, s, 2 * MAX_FILTERSHADERS)) { + struct shaderdata *s = allocshaderslot (d3d, SHADERTYPE_MIDDLE); + if (!psEffect_LoadEffect (d3d, filterd3d->gfx_filtershader[2 * MAX_FILTERSHADERS], true, s, 2 * MAX_FILTERSHADERS)) { filterd3d->gfx_filtershader[2 * MAX_FILTERSHADERS][0] = changed_prefs.gf[filterd3didx].gfx_filtershader[2 * MAX_FILTERSHADERS][0] = 0; } } if (filterd3d->gfx_filtermask[2 * MAX_FILTERSHADERS][0]) { - struct shaderdata *s = allocshaderslot (SHADERTYPE_MASK_AFTER); - createmasktexture (filterd3d->gfx_filtermask[2 * MAX_FILTERSHADERS], s); + struct shaderdata *s = allocshaderslot (d3d, SHADERTYPE_MASK_AFTER); + createmasktexture (d3d, filterd3d->gfx_filtermask[2 * MAX_FILTERSHADERS], s); } for (int i = 0; i < MAX_FILTERSHADERS; i++) { if (filterd3d->gfx_filtershader[i + MAX_FILTERSHADERS][0]) { - struct shaderdata *s = allocshaderslot (SHADERTYPE_AFTER); - if (!psEffect_LoadEffect (filterd3d->gfx_filtershader[i + MAX_FILTERSHADERS], true, s, i + MAX_FILTERSHADERS)) { + struct shaderdata *s = allocshaderslot (d3d, SHADERTYPE_AFTER); + if (!psEffect_LoadEffect (d3d, filterd3d->gfx_filtershader[i + MAX_FILTERSHADERS], true, s, i + MAX_FILTERSHADERS)) { filterd3d->gfx_filtershader[i + MAX_FILTERSHADERS][0] = changed_prefs.gf[filterd3didx].gfx_filtershader[i + MAX_FILTERSHADERS][0] = 0; break; } } if (filterd3d->gfx_filtermask[i + MAX_FILTERSHADERS][0]) { - struct shaderdata *s = allocshaderslot (SHADERTYPE_MASK_AFTER); - createmasktexture (filterd3d->gfx_filtermask[i + MAX_FILTERSHADERS], s); + struct shaderdata *s = allocshaderslot (d3d, SHADERTYPE_MASK_AFTER); + createmasktexture (d3d, filterd3d->gfx_filtermask[i + MAX_FILTERSHADERS], s); } } break; } if (filterd3d->gfx_filter_scanlines > 0) { - createsltexture(); - createscanlines(1); + createsltexture(d3d); + createscanlines(d3d, 1); } if (wasshader && !shaderon) write_log (_T("Falling back to non-shader mode\n")); - createmask2texture (filterd3d->gfx_filteroverlay); + createmask2texture (d3d, filterd3d->gfx_filteroverlay); - createledtexture (); + createledtexture (d3d); - hr = D3DXCreateSprite (d3ddev, &sprite); + hr = D3DXCreateSprite (d3d->d3ddev, &d3d->sprite); if (FAILED (hr)) { write_log (_T("%s: D3DXSprite failed: %s\n"), D3DHEAD, D3D_ErrorString (hr)); } int curw = CURSORMAXWIDTH, curh = CURSORMAXHEIGHT; - cursorsurfaced3d = createtext (curw, curh, D3DFMT_A8R8G8B8); - cursor_v = false; - cursor_scale = false; + d3d->cursorsurfaced3d = createtext (d3d, curw, curh, D3DFMT_A8R8G8B8); + d3d->cursor_v = false; + d3d->cursor_scale = false; vbsize = sizeof (struct TLVERTEX) * NUMVERTICES; - if (FAILED (hr = d3ddev->CreateVertexBuffer (vbsize, D3DUSAGE_WRITEONLY, - D3DFVF_TLVERTEX, D3DPOOL_DEFAULT, &vertexBuffer, NULL))) { + if (FAILED (hr = d3d->d3ddev->CreateVertexBuffer (vbsize, D3DUSAGE_WRITEONLY, + D3DFVF_TLVERTEX, D3DPOOL_DEFAULT, &d3d->vertexBuffer, NULL))) { write_log (_T("%s: failed to create vertex buffer: %s\n"), D3DHEAD, D3D_ErrorString (hr)); return 0; } - createvertex (); - if (FAILED (hr = d3ddev->SetFVF (D3DFVF_TLVERTEX))) + createvertex (d3d); + if (FAILED (hr = d3d->d3ddev->SetFVF (D3DFVF_TLVERTEX))) write_log (_T("%s: SetFVF failed: %s\n"), D3DHEAD, D3D_ErrorString (hr)); - if (FAILED (hr = d3ddev->SetStreamSource (0, vertexBuffer, 0, sizeof (struct TLVERTEX)))) + if (FAILED (hr = d3d->d3ddev->SetStreamSource (0, d3d->vertexBuffer, 0, sizeof (struct TLVERTEX)))) write_log (_T("%s: SetStreamSource failed: %s\n"), D3DHEAD, D3D_ErrorString (hr)); - hr = d3ddev->SetRenderState (D3DRS_CULLMODE, D3DCULL_NONE); - hr = d3ddev->SetRenderState (D3DRS_LIGHTING, FALSE); + hr = d3d->d3ddev->SetRenderState (D3DRS_CULLMODE, D3DCULL_NONE); + hr = d3d->d3ddev->SetRenderState (D3DRS_LIGHTING, FALSE); - settransform (NULL); + settransform (d3d, NULL); return 1; } -static void D3D_free2 (void) +static void D3D_free2 (struct d3dstruct *d3d) { - invalidatedeviceobjects (); - if (screenshotsurface) - screenshotsurface->Release(); - screenshotsurface = NULL; - if (d3ddev) { - d3ddev->Release (); - d3ddev = NULL; + invalidatedeviceobjects (d3d); + if (d3d->screenshotsurface) + d3d->screenshotsurface->Release(); + d3d->screenshotsurface = NULL; + if (d3d->d3ddev) { + d3d->d3ddev->Release (); + d3d->d3ddev = NULL; } - if (d3d) { - d3d->Release (); - d3d = NULL; + if (d3d->d3d) { + d3d->d3d->Release (); + d3d->d3d = NULL; } - d3d_enabled = 0; - psActive = FALSE; - resetcount = 0; - devicelost = 0; - renderdisabled = false; + d3d->d3d_enabled = 0; + d3d->psActive = FALSE; + d3d->resetcount = 0; + d3d->devicelost = 0; + d3d->renderdisabled = false; changed_prefs.leds_on_screen &= ~STATUSLINE_TARGET; currprefs.leds_on_screen &= ~STATUSLINE_TARGET; } void D3D_free (bool immediate) { + struct d3dstruct *d3d = &d3ddata[0]; if (!fakemodewaitms || immediate) { - waitfakemode (); - D3D_free2 (); - ddraw_fs_hack_free (); + waitfakemode (d3d); + D3D_free2 (d3d); + ddraw_fs_hack_free (d3d); return; } } @@ -2231,6 +2244,7 @@ void D3D_free (bool immediate) bool D3D_getvblankpos (int *vpos) { + struct d3dstruct *d3d = &d3ddata[0]; HRESULT hr; D3DRASTER_STATUS rt; #if VBLANKDEBUG @@ -2238,18 +2252,18 @@ bool D3D_getvblankpos (int *vpos) static BOOL lastinvblank; #endif *vpos = -2; - if (!isd3d ()) + if (!isd3d (d3d)) return false; - if (d3dswapchain) - hr = d3dswapchain->GetRasterStatus (&rt); + if (d3d->d3dswapchain) + hr = d3d->d3dswapchain->GetRasterStatus (&rt); else - hr = d3ddev->GetRasterStatus (0, &rt); + hr = d3d->d3ddev->GetRasterStatus (0, &rt); if (FAILED (hr)) { write_log (_T("%s: GetRasterStatus %s\n"), D3DHEAD, D3D_ErrorString (hr)); return false; } - if (rt.ScanLine > maxscanline) - maxscanline = rt.ScanLine; + if (rt.ScanLine > d3d->maxscanline) + d3d->maxscanline = rt.ScanLine; *vpos = rt.ScanLine; #if VBLANKDEBUG if (lastline != rt.ScanLine || lastinvblank != rt.InVBlank) { @@ -2265,14 +2279,15 @@ bool D3D_getvblankpos (int *vpos) void D3D_vblank_reset (double freq) { - if (!isd3d ()) + struct d3dstruct *d3d = &d3ddata[0]; + if (!isd3d (d3d)) return; } -static int getd3dadapter (IDirect3D9 *d3d) +static int getd3dadapter (IDirect3D9 *id3d) { struct MultiDisplay *md = getdisplay (&currprefs); - int num = d3d->GetAdapterCount (); + int num = id3d->GetAdapterCount (); HMONITOR winmon; POINT pt; @@ -2280,14 +2295,14 @@ static int getd3dadapter (IDirect3D9 *d3d) pt.y = (md->rect.bottom - md->rect.top) / 2 + md->rect.top; winmon = MonitorFromPoint (pt, MONITOR_DEFAULTTONEAREST); for (int i = 0; i < num; i++) { - HMONITOR d3dmon = d3d->GetAdapterMonitor (i); + HMONITOR d3dmon = id3d->GetAdapterMonitor (i); if (d3dmon == winmon) return i; } return D3DADAPTER_DEFAULT; } -static const TCHAR *D3D_init2 (HWND ahwnd, int w_w, int w_h, int depth, int *freq, int mmult) +static const TCHAR *D3D_init2 (struct d3dstruct *d3d, HWND ahwnd, int w_w, int w_h, int depth, int *freq, int mmult) { HRESULT ret, hr; static TCHAR errmsg[300] = { 0 }; @@ -2306,14 +2321,14 @@ static const TCHAR *D3D_init2 (HWND ahwnd, int w_w, int w_h, int depth, int *fre filterd3didx = picasso_on; filterd3d = &currprefs.gf[filterd3didx]; - D3D_free2 (); + D3D_free2 (d3d); if (!currprefs.gfx_api) { _tcscpy (errmsg, _T("D3D: not enabled")); return errmsg; } - xfree (fakebitmap); - fakebitmap = xmalloc (uae_u8, w_w * depth); + xfree (d3d->fakebitmap); + d3d->fakebitmap = xmalloc (uae_u8, w_w * depth); d3dx = LoadLibrary (D3DX9DLL); if (d3dx == NULL) { @@ -2334,7 +2349,7 @@ static const TCHAR *D3D_init2 (HWND ahwnd, int w_w, int w_h, int depth, int *fre D3D_goodenough (); D3D_canshaders (); - d3d_ex = FALSE; + d3d->d3d_ex = FALSE; d3dDLL = LoadLibrary (_T("D3D9.DLL")); if (d3dDLL == NULL) { _tcscpy (errmsg, _T("Direct3D: DirectX 9 or newer required")); @@ -2342,27 +2357,27 @@ static const TCHAR *D3D_init2 (HWND ahwnd, int w_w, int w_h, int depth, int *fre } else { d3dexp = (LPDIRECT3DCREATE9EX)GetProcAddress (d3dDLL, "Direct3DCreate9Ex"); if (d3dexp) - d3d_ex = TRUE; + d3d->d3d_ex = TRUE; } FreeLibrary (d3dDLL); hr = -1; - if (d3d_ex && D3DEX) { - hr = d3dexp (D3D_SDK_VERSION, &d3dex); + if (d3d->d3d_ex && D3DEX) { + hr = d3dexp (D3D_SDK_VERSION, &d3d->d3dex); if (FAILED (hr)) write_log (_T("Direct3D: failed to create D3DEx object: %s\n"), D3D_ErrorString (hr)); - d3d = (IDirect3D9*)d3dex; + d3d->d3d = (IDirect3D9*)d3d->d3dex; } if (FAILED (hr)) { - d3d_ex = 0; - d3dex = NULL; - d3d = Direct3DCreate9 (D3D_SDK_VERSION); - if (d3d == NULL) { + d3d->d3d_ex = 0; + d3d->d3dex = NULL; + d3d->d3d = Direct3DCreate9 (D3D_SDK_VERSION); + if (d3d->d3d == NULL) { D3D_free (true); _tcscpy (errmsg, _T("Direct3D: failed to create D3D object")); return errmsg; } } - if (d3d_ex) + if (d3d->d3d_ex) D3DHEAD = _T("D3D9Ex"); else D3DHEAD = _T("D3D9"); @@ -2375,76 +2390,76 @@ static const TCHAR *D3D_init2 (HWND ahwnd, int w_w, int w_h, int depth, int *fre ap.gfx_backbuffers = 1; } - adapter = getd3dadapter (d3d); + adapter = getd3dadapter (d3d->d3d); - modeex.Size = sizeof modeex; - if (d3dex && D3DEX) { + d3d->modeex.Size = sizeof d3d->modeex; + if (d3d->d3dex && D3DEX) { LUID luid; - hr = d3dex->GetAdapterLUID (adapter, &luid); - hr = d3dex->GetAdapterDisplayModeEx (adapter, &modeex, NULL); + hr = d3d->d3dex->GetAdapterLUID (adapter, &luid); + hr = d3d->d3dex->GetAdapterDisplayModeEx (adapter, &d3d->modeex, NULL); } - if (FAILED (hr = d3d->GetAdapterDisplayMode (adapter, &mode))) + if (FAILED (hr = d3d->d3d->GetAdapterDisplayMode (adapter, &mode))) write_log (_T("%s: GetAdapterDisplayMode failed %s\n"), D3DHEAD, D3D_ErrorString (hr)); - if (FAILED (hr = d3d->GetDeviceCaps (adapter, D3DDEVTYPE_HAL, &d3dCaps))) + if (FAILED (hr = d3d->d3d->GetDeviceCaps (adapter, D3DDEVTYPE_HAL, &d3dCaps))) write_log (_T("%s: GetDeviceCaps failed %s\n"), D3DHEAD, D3D_ErrorString (hr)); - if (SUCCEEDED (hr = d3d->GetAdapterIdentifier (adapter, 0, &did))) { + if (SUCCEEDED (hr = d3d->d3d->GetAdapterIdentifier (adapter, 0, &did))) { TCHAR *s = au (did.Description); write_log (_T("Device name: '%s' %llx.%x\n"), s, did.DriverVersion, did.Revision); xfree (s); } - variablerefresh = ap.gfx_vsync < 0; + d3d->variablerefresh = ap.gfx_vsync < 0; - memset (&dpp, 0, sizeof (dpp)); - dpp.Windowed = isfullscreen () <= 0; - dpp.BackBufferFormat = mode.Format; - dpp.BackBufferCount = ap.gfx_backbuffers; - dpp.SwapEffect = D3DSWAPEFFECT_DISCARD; - dpp.Flags = D3DPRESENTFLAG_LOCKABLE_BACKBUFFER; - dpp.BackBufferWidth = w_w; - dpp.BackBufferHeight = w_h; - dpp.PresentationInterval = variablerefresh ? D3DPRESENT_INTERVAL_DEFAULT : (!ap.gfx_vflip ? D3DPRESENT_INTERVAL_IMMEDIATE : D3DPRESENT_INTERVAL_ONE); + memset (&d3d->dpp, 0, sizeof (d3d->dpp)); + d3d->dpp.Windowed = isfullscreen () <= 0; + d3d->dpp.BackBufferFormat = mode.Format; + d3d->dpp.BackBufferCount = ap.gfx_backbuffers; + d3d->dpp.SwapEffect = D3DSWAPEFFECT_DISCARD; + d3d->dpp.Flags = D3DPRESENTFLAG_LOCKABLE_BACKBUFFER; + d3d->dpp.BackBufferWidth = w_w; + d3d->dpp.BackBufferHeight = w_h; + d3d->dpp.PresentationInterval = d3d->variablerefresh ? D3DPRESENT_INTERVAL_DEFAULT : (!ap.gfx_vflip ? D3DPRESENT_INTERVAL_IMMEDIATE : D3DPRESENT_INTERVAL_ONE); - modeex.Width = w_w; - modeex.Height = w_h; - modeex.RefreshRate = 0; - modeex.ScanLineOrdering = ap.gfx_interlaced ? D3DSCANLINEORDERING_INTERLACED : D3DSCANLINEORDERING_PROGRESSIVE; - modeex.Format = mode.Format; + d3d->modeex.Width = w_w; + d3d->modeex.Height = w_h; + d3d->modeex.RefreshRate = 0; + d3d->modeex.ScanLineOrdering = ap.gfx_interlaced ? D3DSCANLINEORDERING_INTERLACED : D3DSCANLINEORDERING_PROGRESSIVE; + d3d->modeex.Format = mode.Format; - vsync2 = 0; + d3d->vsync2 = 0; int hzmult = 0; if (isfullscreen () > 0) { - dpp.FullScreen_RefreshRateInHz = getrefreshrate (modeex.Width, modeex.Height); - modeex.RefreshRate = dpp.FullScreen_RefreshRateInHz; + d3d->dpp.FullScreen_RefreshRateInHz = getrefreshrate (d3d->modeex.Width, d3d->modeex.Height); + d3d->modeex.RefreshRate = d3d->dpp.FullScreen_RefreshRateInHz; if (vsync > 0) { - dpp.PresentationInterval = D3DPRESENT_INTERVAL_ONE; - getvsyncrate (dpp.FullScreen_RefreshRateInHz, &hzmult); + d3d->dpp.PresentationInterval = D3DPRESENT_INTERVAL_ONE; + getvsyncrate (d3d->dpp.FullScreen_RefreshRateInHz, &hzmult); if (hzmult < 0) { if (!ap.gfx_strobo) { if (d3dCaps.PresentationIntervals & D3DPRESENT_INTERVAL_TWO) - dpp.PresentationInterval = D3DPRESENT_INTERVAL_TWO; + d3d->dpp.PresentationInterval = D3DPRESENT_INTERVAL_TWO; } else { - vsync2 = -2; + d3d->vsync2 = -2; } } else if (hzmult > 0) { - vsync2 = 1; + d3d->vsync2 = 1; } } - *freq = modeex.RefreshRate; + *freq = d3d->modeex.RefreshRate; } else { if (mode.RefreshRate > 0) { if (vsync > 0) { - dpp.PresentationInterval = D3DPRESENT_INTERVAL_ONE; + d3d->dpp.PresentationInterval = D3DPRESENT_INTERVAL_ONE; getvsyncrate(mode.RefreshRate, &hzmult); if (hzmult < 0) { if (!ap.gfx_strobo) { if ((d3dCaps.PresentationIntervals & D3DPRESENT_INTERVAL_TWO) && isfullscreen() > 0) - dpp.PresentationInterval = D3DPRESENT_INTERVAL_TWO; + d3d->dpp.PresentationInterval = D3DPRESENT_INTERVAL_TWO; } else { - vsync2 = -2; + d3d->vsync2 = -2; } } else if (hzmult > 0) { - vsync2 = 1; + d3d->vsync2 = 1; } } *freq = mode.RefreshRate; @@ -2452,24 +2467,24 @@ static const TCHAR *D3D_init2 (HWND ahwnd, int w_w, int w_h, int depth, int *fre } if (vsync < 0) { - vsync2 = 0; - getvsyncrate (isfullscreen() > 0 ? dpp.FullScreen_RefreshRateInHz : mode.RefreshRate, &hzmult); + d3d->vsync2 = 0; + getvsyncrate (isfullscreen() > 0 ? d3d->dpp.FullScreen_RefreshRateInHz : mode.RefreshRate, &hzmult); if (hzmult > 0) { - vsync2 = 1; + d3d->vsync2 = 1; } else if (hzmult < 0) { if (ap.gfx_strobo) { - vsync2 = -2; + d3d->vsync2 = -2; } else if (ap.gfx_vflip) { if ((d3dCaps.PresentationIntervals & D3DPRESENT_INTERVAL_TWO) && isfullscreen() > 0) - dpp.PresentationInterval = D3DPRESENT_INTERVAL_TWO; + d3d->dpp.PresentationInterval = D3DPRESENT_INTERVAL_TWO; else - vsync2 = -1; + d3d->vsync2 = -1; } } } - d3dhwnd = ahwnd; - t_depth = depth; + d3d->d3dhwnd = ahwnd; + d3d->t_depth = depth; flags = D3DCREATE_FPU_PRESERVE | D3DCREATE_MULTITHREADED; // Check if hardware vertex processing is available @@ -2478,45 +2493,45 @@ static const TCHAR *D3D_init2 (HWND ahwnd, int w_w, int w_h, int depth, int *fre } else { flags |= D3DCREATE_SOFTWARE_VERTEXPROCESSING; } - if (d3d_ex && D3DEX) { - ret = d3dex->CreateDeviceEx (adapter, D3DDEVTYPE_HAL, d3dhwnd, flags, &dpp, dpp.Windowed ? NULL : &modeex, &d3ddevex); - d3ddev = d3ddevex; + if (d3d->d3d_ex && D3DEX) { + ret = d3d->d3dex->CreateDeviceEx (adapter, D3DDEVTYPE_HAL, d3d->d3dhwnd, flags, &d3d->dpp, d3d->dpp.Windowed ? NULL : &d3d->modeex, &d3d->d3ddevex); + d3d->d3ddev = d3d->d3ddevex; } else { - ret = d3d->CreateDevice (adapter, D3DDEVTYPE_HAL, d3dhwnd, flags, &dpp, &d3ddev); + ret = d3d->d3d->CreateDevice (adapter, D3DDEVTYPE_HAL, d3d->d3dhwnd, flags, &d3d->dpp, &d3d->d3ddev); } if (FAILED (ret) && (flags & D3DCREATE_PUREDEVICE)) { flags &= ~D3DCREATE_PUREDEVICE; - if (d3d_ex && D3DEX) { - ret = d3dex->CreateDeviceEx (adapter, D3DDEVTYPE_HAL, d3dhwnd, flags, &dpp, dpp.Windowed ? NULL : &modeex, &d3ddevex); - d3ddev = d3ddevex; + if (d3d->d3d_ex && D3DEX) { + ret = d3d->d3dex->CreateDeviceEx (adapter, D3DDEVTYPE_HAL, d3d->d3dhwnd, flags, &d3d->dpp, d3d->dpp.Windowed ? NULL : &d3d->modeex, &d3d->d3ddevex); + d3d->d3ddev = d3d->d3ddevex; } else { - ret = d3d->CreateDevice (adapter, D3DDEVTYPE_HAL, d3dhwnd, flags, &dpp, &d3ddev); + ret = d3d->d3d->CreateDevice (adapter, D3DDEVTYPE_HAL, d3d->d3dhwnd, flags, &d3d->dpp, &d3d->d3ddev); } if (FAILED (ret) && (flags & D3DCREATE_HARDWARE_VERTEXPROCESSING)) { flags &= ~D3DCREATE_HARDWARE_VERTEXPROCESSING; flags |= D3DCREATE_SOFTWARE_VERTEXPROCESSING; - if (d3d_ex && D3DEX) { - ret = d3dex->CreateDeviceEx (adapter, D3DDEVTYPE_HAL, d3dhwnd, flags, &dpp, dpp.Windowed ? NULL : &modeex, &d3ddevex); - d3ddev = d3ddevex; + if (d3d->d3d_ex && D3DEX) { + ret = d3d->d3dex->CreateDeviceEx (adapter, D3DDEVTYPE_HAL, d3d->d3dhwnd, flags, &d3d->dpp, d3d->dpp.Windowed ? NULL : &d3d->modeex, &d3d->d3ddevex); + d3d->d3ddev = d3d->d3ddevex; } else { - ret = d3d->CreateDevice (adapter, D3DDEVTYPE_HAL, d3dhwnd, flags, &dpp, &d3ddev); + ret = d3d->d3d->CreateDevice (adapter, D3DDEVTYPE_HAL, d3d->d3dhwnd, flags, &d3d->dpp, &d3d->d3ddev); } } } if (FAILED (ret)) { - _stprintf (errmsg, _T("%s failed, %s\n"), d3d_ex && D3DEX ? _T("CreateDeviceEx") : _T("CreateDevice"), D3D_ErrorString (ret)); - if (ret == D3DERR_INVALIDCALL && dpp.Windowed == 0 && dpp.FullScreen_RefreshRateInHz && !ddraw_fs) { + _stprintf (errmsg, _T("%s failed, %s\n"), d3d->d3d_ex && D3DEX ? _T("CreateDeviceEx") : _T("CreateDevice"), D3D_ErrorString (ret)); + if (ret == D3DERR_INVALIDCALL && d3d->dpp.Windowed == 0 && d3d->dpp.FullScreen_RefreshRateInHz && !d3d->ddraw_fs) { write_log (_T("%s\n"), errmsg); write_log (_T("%s: Retrying fullscreen with DirectDraw\n"), D3DHEAD); - if (ddraw_fs_hack_init ()) { + if (ddraw_fs_hack_init (d3d)) { const TCHAR *err2 = D3D_init (ahwnd, w_w, w_h, depth, freq, mmult); if (err2) - ddraw_fs_hack_free (); + ddraw_fs_hack_free (d3d); return err2; } } - if (d3d_ex && D3DEX) { + if (d3d->d3d_ex && D3DEX) { write_log (_T("%s\n"), errmsg); D3DEX = 0; return D3D_init (ahwnd, w_w, w_h, depth, freq, mmult); @@ -2526,12 +2541,12 @@ static const TCHAR *D3D_init2 (HWND ahwnd, int w_w, int w_h, int depth, int *fre } if (d3dCaps.PixelShaderVersion >= D3DPS_VERSION(2, 0)) - psEnabled = TRUE; + d3d->psEnabled = TRUE; else - psEnabled = FALSE; + d3d->psEnabled = FALSE; - max_texture_w = d3dCaps.MaxTextureWidth; - max_texture_h = d3dCaps.MaxTextureHeight; + d3d->max_texture_w = d3dCaps.MaxTextureWidth; + d3d->max_texture_h = d3dCaps.MaxTextureHeight; write_log (_T("%s: %08X %08X %08X %08X"), D3DHEAD, flags, d3dCaps.Caps, d3dCaps.Caps2, d3dCaps.Caps3); if (d3dCaps.TextureCaps & D3DPTEXTURECAPS_SQUAREONLY) @@ -2553,53 +2568,53 @@ static const TCHAR *D3D_init2 (HWND ahwnd, int w_w, int w_h, int depth, int *fre D3DHEAD, (d3dCaps.PixelShaderVersion >> 8) & 0xff, d3dCaps.PixelShaderVersion & 0xff, (d3dCaps.VertexShaderVersion >> 8) & 0xff, d3dCaps.VertexShaderVersion & 0xff, - modeex.Width, modeex.Height, - dpp.FullScreen_RefreshRateInHz, + d3d->modeex.Width, d3d->modeex.Height, + d3d->dpp.FullScreen_RefreshRateInHz, ap.gfx_interlaced ? _T("i") : _T("p"), - dpp.Windowed ? _T("") : _T(" FS"), + d3d->dpp.Windowed ? _T("") : _T(" FS"), vsync, ap.gfx_backbuffers, ap.gfx_vflip < 0 ? _T("WE") : (ap.gfx_vflip > 0 ? _T("WS") : _T("I")), - t_depth, adapter, - max_texture_w, max_texture_h + d3d->t_depth, adapter, + d3d->max_texture_w, d3d->max_texture_h ); - if ((d3dCaps.PixelShaderVersion < D3DPS_VERSION(2,0) || !psEnabled || max_texture_w < 2048 || max_texture_h < 2048 || (!shaderon && SHADER > 0)) && d3d_ex) { + if ((d3dCaps.PixelShaderVersion < D3DPS_VERSION(2,0) || !d3d->psEnabled || d3d->max_texture_w < 2048 || d3d->max_texture_h < 2048 || (!shaderon && SHADER > 0)) && d3d->d3d_ex) { D3DEX = 0; write_log (_T("Disabling D3D9Ex\n")); - if (d3ddev) { - d3ddev->Release (); - d3ddev = NULL; + if (d3d->d3ddev) { + d3d->d3ddev->Release (); + d3d->d3ddev = NULL; } - if (d3d) { - d3d->Release (); - d3d = NULL; + if (d3d->d3d) { + d3d->d3d->Release (); + d3d->d3d = NULL; } - d3ddevex = NULL; + d3d->d3ddevex = NULL; return D3D_init (ahwnd, w_w, w_h, depth, freq, mmult); } if (!shaderon) write_log (_T("Using non-shader version\n")); - dmultx = mmult; - dmult = S2X_getmult (); + d3d->dmultx = mmult; + d3d->dmult = S2X_getmult (); - window_w = w_w; - window_h = w_h; + d3d->window_w = w_w; + d3d->window_h = w_h; - if (max_texture_w < w_w || max_texture_h < w_h) { + if (d3d->max_texture_w < w_w || d3d->max_texture_h < w_h) { _stprintf (errmsg, _T("%s: %d * %d or bigger texture support required\nYour card's maximum texture size is only %d * %d"), - D3DHEAD, w_w, w_h, max_texture_w, max_texture_h); + D3DHEAD, w_w, w_h, d3d->max_texture_w, d3d->max_texture_h); return errmsg; } - while (dmultx > 1 && (w_w * dmultx > max_texture_w || w_h * dmultx > max_texture_h)) - dmultx--; + while (d3d->dmultx > 1 && (w_w * d3d->dmultx > d3d->max_texture_w || w_h * d3d->dmultx > d3d->max_texture_h)) + d3d->dmultx--; - required_sl_texture_w = w_w; - required_sl_texture_h = w_h; - if (filterd3d->gfx_filter_scanlines > 0 && (max_texture_w < w_w || max_texture_h < w_h)) { + d3d->required_sl_texture_w = w_w; + d3d->required_sl_texture_h = w_h; + if (filterd3d->gfx_filter_scanlines > 0 && (d3d->max_texture_w < w_w || d3d->max_texture_h < w_h)) { gui_message (_T("%s: %d * %d or bigger texture support required for scanlines (max is only %d * %d)\n"), D3DHEAD, _T("Scanlines disabled."), - required_sl_texture_w, required_sl_texture_h, max_texture_w, max_texture_h); + d3d->required_sl_texture_w, d3d->required_sl_texture_h, d3d->max_texture_w, d3d->max_texture_h); changed_prefs.gf[filterd3didx].gfx_filter_scanlines = filterd3d->gfx_filter_scanlines = 0; } @@ -2607,50 +2622,50 @@ static const TCHAR *D3D_init2 (HWND ahwnd, int w_w, int w_h, int depth, int *fre { case 32: default: - tformat = D3DFMT_X8R8G8B8; + d3d->tformat = D3DFMT_X8R8G8B8; break; case 15: - tformat = D3DFMT_X1R5G5B5; + d3d->tformat = D3DFMT_X1R5G5B5; break; case 16: - tformat = D3DFMT_R5G6B5; + d3d->tformat = D3DFMT_R5G6B5; break; } changed_prefs.leds_on_screen |= STATUSLINE_TARGET; currprefs.leds_on_screen |= STATUSLINE_TARGET; - if (!restoredeviceobjects ()) { + if (!restoredeviceobjects (d3d)) { D3D_free (true); _stprintf (errmsg, _T("%s: initialization failed."), D3DHEAD); return errmsg; } - maxscanline = 0; - d3d_enabled = 1; - wasstilldrawing_broken = true; + d3d->maxscanline = 0; + d3d->d3d_enabled = 1; + d3d->wasstilldrawing_broken = true; - if ((vsync < 0 || variablerefresh) && ap.gfx_vflip == 0) { - hr = d3ddev->CreateQuery(D3DQUERYTYPE_EVENT, &query); + if ((vsync < 0 || d3d->variablerefresh) && ap.gfx_vflip == 0) { + hr = d3d->d3ddev->CreateQuery(D3DQUERYTYPE_EVENT, &d3d->query); if (FAILED (hr)) write_log (_T("%s: CreateQuery(D3DQUERYTYPE_EVENT) failed: %s\n"), D3DHEAD, D3D_ErrorString (hr)); } - if (d3ddevex) { + if (d3d->d3ddevex) { UINT v = 12345; - hr = d3ddevex->GetMaximumFrameLatency (&v); + hr = d3d->d3ddevex->GetMaximumFrameLatency (&v); if (FAILED (hr)) { write_log (_T("%s: GetMaximumFrameLatency() failed: %s\n"), D3DHEAD, D3D_ErrorString (hr)); v = 1; } hr = S_OK; if (forcedframelatency >= 0) - hr = d3ddevex->SetMaximumFrameLatency (forcedframelatency); - else if (dpp.PresentationInterval == D3DPRESENT_INTERVAL_IMMEDIATE && (v > 1 || !vsync)) - hr = d3ddevex->SetMaximumFrameLatency ((vsync || variablerefresh) ? (hzmult < 0 && !ap.gfx_strobo && !variablerefresh ? 2 : 1) : 0); + hr = d3d->d3ddevex->SetMaximumFrameLatency (forcedframelatency); + else if (d3d->dpp.PresentationInterval == D3DPRESENT_INTERVAL_IMMEDIATE && (v > 1 || !vsync)) + hr = d3d->d3ddevex->SetMaximumFrameLatency ((vsync || d3d->variablerefresh) ? (hzmult < 0 && !ap.gfx_strobo && !d3d->variablerefresh ? 2 : 1) : 0); if (FAILED (hr)) write_log (_T("%s: SetMaximumFrameLatency() failed: %s\n"), D3DHEAD, D3D_ErrorString (hr)); } - hr = d3ddev->CreateOffscreenPlainSurface(w_w, w_h, tformat, D3DPOOL_SYSTEMMEM, &screenshotsurface, NULL); + hr = d3d->d3ddev->CreateOffscreenPlainSurface(w_w, w_h, d3d->tformat, D3DPOOL_SYSTEMMEM, &d3d->screenshotsurface, NULL); if (FAILED(hr)) { write_log(_T("%s: CreateOffscreenPlainSurface failed: %s\n"), D3DHEAD, D3D_ErrorString(hr)); } @@ -2671,15 +2686,16 @@ static struct d3d_initargs d3dargs; static void *D3D_init_start (void *p) { + struct d3dstruct *d3d = &d3ddata[0]; struct timeval tv1, tv2; gettimeofday (&tv1, NULL); sleep_millis (1000); write_log (_T("Threaded D3D_init() start (free)\n")); - D3D_free2 (); + D3D_free2 (d3d); sleep_millis (1000); write_log (_T("Threaded D3D_init() start (init)\n")); - const TCHAR *t = D3D_init2 (d3dargs.hwnd, d3dargs.w, d3dargs.h, d3dargs.depth, d3dargs.freq, d3dargs.mmult); + const TCHAR *t = D3D_init2 (d3d, d3dargs.hwnd, d3dargs.w, d3dargs.h,d3dargs.depth, d3dargs.freq, d3dargs.mmult); if (t) { gui_message (_T("Threaded D3D_init() returned error '%s'\n"), t); } @@ -2695,156 +2711,161 @@ static void *D3D_init_start (void *p) sleep_millis (10); } write_log (_T("Threaded D3D_init() finished\n")); - frames_since_init = 0; - fakemode = false; + d3d->frames_since_init = 0; + d3d->fakemode = false; return NULL; } const TCHAR *D3D_init (HWND ahwnd, int w_w, int w_h, int depth, int *freq, int mmult) { + struct d3dstruct *d3d = &d3ddata[0]; + if (!fakemodewaitms) - return D3D_init2 (ahwnd, w_w, w_h, depth, freq, mmult); - fakemode = true; + return D3D_init2 (d3d, ahwnd, w_w, w_h, depth, freq, mmult); + d3d->fakemode = true; d3dargs.hwnd = ahwnd; d3dargs.w = w_w; d3dargs.h = w_h; d3dargs.depth = depth; d3dargs.mmult = mmult; d3dargs.freq = freq; - uae_start_thread_fast (D3D_init_start, NULL, &fakemodetid); + uae_start_thread_fast (D3D_init_start, NULL, &d3d->fakemodetid); return NULL; } -static bool alloctextures (void) +static bool alloctextures (struct d3dstruct *d3d) { - if (!createtexture (tout_w, tout_h, window_w, window_h)) + if (!createtexture (d3d, d3d->tout_w, d3d->tout_h, d3d->window_w, d3d->window_h)) return false; - if (!createamigatexture (tin_w, tin_h)) + if (!createamigatexture (d3d, d3d->tin_w, d3d->tin_h)) return false; return true; } bool D3D_alloctexture (int w, int h) { - tin_w = w * dmult; - tin_h = h * dmult; + struct d3dstruct *d3d = &d3ddata[0]; - tout_w = tin_w * dmultx; - tout_h = tin_h * dmultx; + d3d->tin_w = w * d3d->dmult; + d3d->tin_h = h * d3d->dmult; - if (fakemode) + d3d->tout_w = d3d->tin_w * d3d->dmultx; + d3d->tout_h = d3d->tin_h * d3d->dmultx; + + if (d3d->fakemode) return false; changed_prefs.leds_on_screen |= STATUSLINE_TARGET; currprefs.leds_on_screen |= STATUSLINE_TARGET; - freetextures (); - return alloctextures (); + freetextures (d3d); + return alloctextures (d3d); } static HRESULT reset (void) { + struct d3dstruct *d3d = &d3ddata[0]; HRESULT hr; - bool oldrender = renderdisabled; - renderdisabled = true; - if (d3dex) - hr = d3ddevex->ResetEx (&dpp, dpp.Windowed ? NULL : &modeex); + bool oldrender = d3d->renderdisabled; + d3d->renderdisabled = true; + if (d3d->d3dex) + hr = d3d->d3ddevex->ResetEx (&d3d->dpp, d3d->dpp.Windowed ? NULL : &d3d->modeex); else - hr = d3ddev->Reset (&dpp); - renderdisabled = oldrender; + hr = d3d->d3ddev->Reset (&d3d->dpp); + d3d->renderdisabled = oldrender; return hr; } -static int D3D_needreset (void) +static int D3D_needreset (struct d3dstruct *d3d) { HRESULT hr; bool do_dd = false; - if (!devicelost) + if (!d3d->devicelost) return -1; - if (d3dex) - hr = d3ddevex->CheckDeviceState (d3dhwnd); + if (d3d->d3dex) + hr = d3d->d3ddevex->CheckDeviceState (d3d->d3dhwnd); else - hr = d3ddev->TestCooperativeLevel (); + hr = d3d->d3ddev->TestCooperativeLevel (); if (hr == S_PRESENT_OCCLUDED) { // no need to draw anything return 1; } if (hr == D3DERR_DEVICELOST) { - renderdisabled = true; + d3d->renderdisabled = true; // lost but can't be reset yet return 1; } if (hr == D3DERR_DEVICENOTRESET) { // lost and can be reset write_log (_T("%s: DEVICENOTRESET\n"), D3DHEAD); - devicelost = 2; - invalidatedeviceobjects (); - freetextures (); + d3d->devicelost = 2; + invalidatedeviceobjects (d3d); + freetextures (d3d); hr = reset (); if (FAILED (hr)) { write_log (_T("%s: Reset failed %s\n"), D3DHEAD, D3D_ErrorString (hr)); - resetcount++; - if (resetcount > 2 || hr == D3DERR_DEVICEHUNG) { + d3d->resetcount++; + if (d3d->resetcount > 2 || hr == D3DERR_DEVICEHUNG) { changed_prefs.gfx_api = 0; write_log (_T("%s: Too many failed resets, disabling Direct3D mode\n"), D3DHEAD); } return 1; } - devicelost = 0; + d3d->devicelost = 0; write_log (_T("%s: Reset succeeded\n"), D3DHEAD); - renderdisabled = false; - restoredeviceobjects (); - alloctextures (); + d3d->renderdisabled = false; + restoredeviceobjects (d3d); + alloctextures (d3d); return -1; } else if (hr == S_PRESENT_MODE_CHANGED) { - write_log (_T("%s: S_PRESENT_MODE_CHANGED (%d,%d)\n"), D3DHEAD, ddraw_fs, ddraw_fs_attempt); + write_log (_T("%s: S_PRESENT_MODE_CHANGED (%d,%d)\n"), D3DHEAD, d3d->ddraw_fs, d3d->ddraw_fs_attempt); #if 0 - if (!ddraw_fs) { - ddraw_fs_attempt++; - if (ddraw_fs_attempt >= 5) { + if (!d3d->ddraw_fs) { + d3d->ddraw_fs_attempt++; + if (d3d->ddraw_fs_attempt >= 5) { do_dd = true; } } #endif } if (SUCCEEDED (hr)) { - devicelost = 0; - invalidatedeviceobjects (); + d3d->devicelost = 0; + invalidatedeviceobjects (d3d); if (do_dd) { write_log (_T("%s: S_PRESENT_MODE_CHANGED, Retrying fullscreen with DirectDraw\n"), D3DHEAD); - ddraw_fs_hack_init (); + ddraw_fs_hack_init (d3d); } hr = reset (); if (FAILED (hr)) write_log (_T("%s: Reset failed %s\n"), D3DHEAD, D3D_ErrorString (hr)); - restoredeviceobjects (); + restoredeviceobjects (d3d); return -1; } write_log (_T("%s: TestCooperativeLevel %s\n"), D3DHEAD, D3D_ErrorString (hr)); return 0; } -static void D3D_showframe2 (bool dowait) +static void D3D_showframe2 (struct d3dstruct *d3d, bool dowait) { HRESULT hr; - if (!isd3d ()) + if (!isd3d (d3d)) return; for (;;) { - if (d3dswapchain) - hr = d3dswapchain->Present (NULL, NULL, NULL, NULL, dowait ? 0 : D3DPRESENT_DONOTWAIT); + if (d3d->d3dswapchain) + hr = d3d->d3dswapchain->Present (NULL, NULL, NULL, NULL, dowait ? 0 : D3DPRESENT_DONOTWAIT); else - hr = d3ddev->Present (NULL, NULL, NULL, NULL); + hr = d3d->d3ddev->Present (NULL, NULL, NULL, NULL); if (hr == D3DERR_WASSTILLDRAWING) { - wasstilldrawing_broken = false; + d3d->wasstilldrawing_broken = false; if (!dowait) return; sleep_millis (1); continue; } else if (hr == S_PRESENT_OCCLUDED) { - renderdisabled = true; + d3d->renderdisabled = true; } else if (hr == S_PRESENT_MODE_CHANGED) { // In most cases mode actually didn't change but // D3D is just being stupid and not accepting @@ -2855,12 +2876,12 @@ static void D3D_showframe2 (bool dowait) } else if (FAILED (hr)) { write_log (_T("%s: Present() %s\n"), D3DHEAD, D3D_ErrorString (hr)); if (hr == D3DERR_DEVICELOST || hr == S_PRESENT_MODE_CHANGED) { - devicelost = 1; - renderdisabled = true; + d3d->devicelost = 1; + d3d->renderdisabled = true; write_log (_T("%s: mode changed or fullscreen focus lost\n"), D3DHEAD); } } else { - ddraw_fs_attempt = 0; + d3d->ddraw_fs_attempt = 0; } return; } @@ -2868,23 +2889,26 @@ static void D3D_showframe2 (bool dowait) void D3D_restore (void) { - renderdisabled = false; + struct d3dstruct *d3d = &d3ddata[0]; + + d3d->renderdisabled = false; } void D3D_clear (void) { + struct d3dstruct *d3d = &d3ddata[0]; int i; HRESULT hr; - if (!isd3d ()) + if (!isd3d (d3d)) return; for (i = 0; i < 2; i++) { - hr = d3ddev->Clear (0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 0, d3ddebug ? 0x80 : 0x00), 0, 0); - D3D_showframe2 (true); + hr = d3d->d3ddev->Clear (0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, 0, d3ddebug ? 0x80 : 0x00), 0, 0); + D3D_showframe2 (d3d, true); } } -static LPDIRECT3DTEXTURE9 processshader(LPDIRECT3DTEXTURE9 srctex, struct shaderdata *s, bool rendertarget) +static LPDIRECT3DTEXTURE9 processshader(struct d3dstruct *d3d, LPDIRECT3DTEXTURE9 srctex, struct shaderdata *s, bool rendertarget) { HRESULT hr; UINT uPasses, uPass; @@ -2895,24 +2919,24 @@ static LPDIRECT3DTEXTURE9 processshader(LPDIRECT3DTEXTURE9 srctex, struct shader if (!psEffect_SetTextures (srctex, s)) return NULL; if (s->psPreProcess) { - if (!psEffect_SetMatrices (&m_matPreProj, &m_matPreView, &m_matPreWorld, s)) + if (!psEffect_SetMatrices (&d3d->m_matPreProj, &d3d->m_matPreView, &d3d->m_matPreWorld, s)) return NULL; - if (FAILED (hr = d3ddev->GetRenderTarget (0, &lpRenderTarget))) + if (FAILED (hr = d3d->d3ddev->GetRenderTarget (0, &lpRenderTarget))) write_log (_T("%s: GetRenderTarget: %s\n"), D3DHEAD, D3D_ErrorString (hr)); lpWorkTexture = s->lpWorkTexture1; lpNewRenderTarget = NULL; pass2: if (FAILED (hr = lpWorkTexture->GetSurfaceLevel (0, &lpNewRenderTarget))) write_log (_T("%s: GetSurfaceLevel: %s\n"), D3DHEAD, D3D_ErrorString (hr)); - if (FAILED (hr = d3ddev->SetRenderTarget (0, lpNewRenderTarget))) + if (FAILED (hr = d3d->d3ddev->SetRenderTarget (0, lpNewRenderTarget))) write_log (_T("%s: SetRenderTarget: %s\n"), D3DHEAD, D3D_ErrorString (hr)); uPasses = 0; if (psEffect_Begin ((lpWorkTexture == s->lpWorkTexture1) ? psEffect_PreProcess1 : psEffect_PreProcess2, &uPasses, s)) { for (uPass = 0; uPass < uPasses; uPass++) { if (psEffect_BeginPass (s->pEffect, uPass)) { - if (FAILED (hr = d3ddev->DrawPrimitive (D3DPT_TRIANGLESTRIP, 4, 2))) { + if (FAILED (hr = d3d->d3ddev->DrawPrimitive (D3DPT_TRIANGLESTRIP, 4, 2))) { write_log (_T("%s: Effect DrawPrimitive failed: %s\n"), D3DHEAD, D3D_ErrorString (hr)); } psEffect_EndPass (s->pEffect); @@ -2920,7 +2944,7 @@ pass2: } psEffect_End (s->pEffect); } - if (FAILED (hr = d3ddev->SetRenderTarget (0, lpRenderTarget))) + if (FAILED (hr = d3d->d3ddev->SetRenderTarget (0, lpRenderTarget))) write_log (_T("%s: Effect RenderTarget reset failed: %s\n"), D3DHEAD, D3D_ErrorString (hr)); lpNewRenderTarget->Release (); lpNewRenderTarget = NULL; @@ -2931,15 +2955,15 @@ pass2: lpRenderTarget->Release (); lpRenderTarget = NULL; } - psEffect_SetMatrices (&m_matProj2, &m_matView2, &m_matWorld2, s); + psEffect_SetMatrices (&d3d->m_matProj2, &d3d->m_matView2, &d3d->m_matWorld2, s); if (rendertarget) { #if TWOPASS - if (FAILED (hr = d3ddev->GetRenderTarget (0, &lpRenderTarget))) + if (FAILED (hr = d3d->d3ddev->GetRenderTarget (0, &lpRenderTarget))) write_log (_T("%s: GetRenderTarget: %s\n"), D3DHEAD, D3D_ErrorString (hr)); if (FAILED (hr = s->lpTempTexture->GetSurfaceLevel (0, &lpNewRenderTarget))) write_log (_T("%s: GetSurfaceLevel: %s\n"), D3DHEAD, D3D_ErrorString (hr)); - if (FAILED (hr = d3ddev->SetRenderTarget (0, lpNewRenderTarget))) + if (FAILED (hr = d3d->d3ddev->SetRenderTarget (0, lpNewRenderTarget))) write_log (_T("%s: SetRenderTarget: %s\n"), D3DHEAD, D3D_ErrorString (hr)); #endif } @@ -2949,7 +2973,7 @@ pass2: for (uPass = 0; uPass < uPasses; uPass++) { if (!psEffect_BeginPass (s->pEffect, uPass)) return NULL; - if (FAILED (hr = d3ddev->DrawPrimitive (D3DPT_TRIANGLESTRIP, 0, 2))) + if (FAILED (hr = d3d->d3ddev->DrawPrimitive (D3DPT_TRIANGLESTRIP, 0, 2))) write_log (_T("%s: Effect2 DrawPrimitive failed: %s\n"), D3DHEAD, D3D_ErrorString (hr)); psEffect_EndPass (s->pEffect); } @@ -2957,7 +2981,7 @@ pass2: } if (rendertarget) { #if TWOPASS - if (FAILED (hr = d3ddev->SetRenderTarget (0, lpRenderTarget))) + if (FAILED (hr = d3d->d3ddev->SetRenderTarget (0, lpRenderTarget))) write_log (_T("%s: SetRenderTarget: %s\n"), D3DHEAD, D3D_ErrorString (hr)); lpNewRenderTarget->Release (); lpRenderTarget->Release (); @@ -2966,49 +2990,49 @@ pass2: return s->lpTempTexture; } -static void D3D_render2 (void) +static void D3D_render2 (struct d3dstruct *d3d) { HRESULT hr; - LPDIRECT3DTEXTURE9 srctex = texture; + LPDIRECT3DTEXTURE9 srctex = d3d->texture; UINT uPasses, uPass; - if (!isd3d () || !texture) + if (!isd3d (d3d) || !d3d->texture) return; - hr = d3ddev->Clear (0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, d3ddebug ? 0x80 : 0, 0), 0, 0); + hr = d3d->d3ddev->Clear (0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, d3ddebug ? 0x80 : 0, 0), 0, 0); - if (FAILED (hr = d3ddev->BeginScene ())) { + if (FAILED (hr = d3d->d3ddev->BeginScene ())) { write_log (_T("%s: BeginScene: %s\n"), D3DHEAD, D3D_ErrorString (hr)); return; } - if (shaderon > 0 && shaders[SHADER_POST].pEffect) { + if (shaderon > 0 && d3d->shaders[SHADER_POST].pEffect) { for (int i = 0; i < MAX_SHADERS; i++) { - struct shaderdata *s = &shaders[i]; + struct shaderdata *s = &d3d->shaders[i]; if (s->type == SHADERTYPE_BEFORE) - settransform_pre (s); + settransform_pre (d3d, s); if (s->type == SHADERTYPE_MIDDLE) { - m_matProj = m_matProj_out; - m_matView = m_matView_out; - m_matWorld = m_matWorld_out; + d3d->m_matProj = d3d->m_matProj_out; + d3d->m_matView = d3d->m_matView_out; + d3d->m_matWorld = d3d->m_matWorld_out; } if (s->type == SHADERTYPE_BEFORE || s->type == SHADERTYPE_MIDDLE) { - settransform (s); - srctex = processshader (srctex, s, true); + settransform (d3d, s); + srctex = processshader (d3d, srctex, s, true); if (!srctex) return; } } } - m_matProj = m_matProj_out; - m_matView = m_matView_out; - m_matWorld = m_matWorld_out; + d3d->m_matProj = d3d->m_matProj_out; + d3d->m_matView = d3d->m_matView_out; + d3d->m_matWorld = d3d->m_matWorld_out; #if TWOPASS - if (shaderon > 0 && shaders[SHADER_POST].pEffect) { + if (shaderon > 0 && d3d->shaders[SHADER_POST].pEffect) { LPDIRECT3DSURFACE9 lpRenderTarget; LPDIRECT3DSURFACE9 lpNewRenderTarget; - struct shaderdata *s = &shaders[SHADER_POST]; + struct shaderdata *s = &d3d->shaders[SHADER_POST]; LPD3DXEFFECT postEffect = s->pEffect; int after = -1; LPDIRECT3DTEXTURE9 masktexture = NULL; @@ -3016,47 +3040,47 @@ static void D3D_render2 (void) D3DXVECTOR4 texelsize; for (int i = 0; i < MAX_SHADERS; i++) { - struct shaderdata *s = &shaders[i]; + struct shaderdata *s = &d3d->shaders[i]; if (s->type == SHADERTYPE_AFTER) after = i; if (s->masktexture) masktexture = s->masktexture; } - setupscenecoords (); - hr = d3ddev->SetTransform (D3DTS_PROJECTION, &m_matProj); - hr = d3ddev->SetTransform (D3DTS_VIEW, &m_matView); - hr = d3ddev->SetTransform (D3DTS_WORLD, &m_matWorld); + setupscenecoords (d3d); + hr = d3d->d3ddev->SetTransform (D3DTS_PROJECTION, &d3d->m_matProj); + hr = d3d->d3ddev->SetTransform (D3DTS_VIEW, &d3d->m_matView); + hr = d3d->d3ddev->SetTransform (D3DTS_WORLD, &d3d->m_matWorld); - hr = postEffect->SetMatrix (postMatrixSource, &postproj); - hr = postEffect->SetVector (postMaskMult, &maskmult); - hr = postEffect->SetVector (postMaskShift, &maskshift); + hr = postEffect->SetMatrix (d3d->postMatrixSource, &d3d->postproj); + hr = postEffect->SetVector (d3d->postMaskMult, &d3d->maskmult); + hr = postEffect->SetVector (d3d->postMaskShift, &d3d->maskshift); srctex->GetLevelDesc (0, &Desc); texelsize.x = 1.0f / Desc.Width; texelsize.y = 1.0f / Desc.Height; texelsize.z = 1; texelsize.w = 1; - hr = postEffect->SetVector (postTexelSize, &texelsize); - if (postFramecounterHandle) - postEffect->SetFloat(postFramecounterHandle, timeframes); + hr = postEffect->SetVector (d3d->postTexelSize, &texelsize); + if (d3d->postFramecounterHandle) + postEffect->SetFloat(d3d->postFramecounterHandle, timeframes); if (masktexture) { - if (FAILED (hr = postEffect->SetTechnique (postTechnique))) + if (FAILED (hr = postEffect->SetTechnique (d3d->postTechnique))) write_log (_T("%s: SetTechnique(postTechnique) failed: %s\n"), D3DHEAD, D3D_ErrorString (hr)); - if (FAILED (hr = postEffect->SetTexture (postMaskTextureHandle, masktexture))) + if (FAILED (hr = postEffect->SetTexture (d3d->postMaskTextureHandle, masktexture))) write_log (_T("%s: SetTexture(masktexture) failed: %s\n"), D3DHEAD, D3D_ErrorString (hr)); - } else if (sltexture) { - if (FAILED (hr = postEffect->SetTechnique (postTechniqueAlpha))) + } else if (d3d->sltexture) { + if (FAILED (hr = postEffect->SetTechnique (d3d->postTechniqueAlpha))) write_log (_T("%s: SetTechnique(postTechniqueAlpha) failed: %s\n"), D3DHEAD, D3D_ErrorString (hr)); - if (FAILED (hr = postEffect->SetTexture (postMaskTextureHandle, sltexture))) + if (FAILED (hr = postEffect->SetTexture (d3d->postMaskTextureHandle, d3d->sltexture))) write_log (_T("%s: SetTexture(sltexture) failed: %s\n"), D3DHEAD, D3D_ErrorString (hr)); } else { - if (FAILED (hr = postEffect->SetTechnique (postTechniquePlain))) + if (FAILED (hr = postEffect->SetTechnique (d3d->postTechniquePlain))) write_log (_T("%s: SetTechnique(postTechniquePlain) failed: %s\n"), D3DHEAD, D3D_ErrorString (hr)); } - hr = postEffect->SetInt (postFilterMode, filterd3d->gfx_filter_bilinear ? D3DTEXF_LINEAR : D3DTEXF_POINT); + hr = postEffect->SetInt (d3d->postFilterMode, filterd3d->gfx_filter_bilinear ? D3DTEXF_LINEAR : D3DTEXF_POINT); - if (FAILED (hr = postEffect->SetTexture (postSourceTextureHandle, srctex))) + if (FAILED (hr = postEffect->SetTexture (d3d->postSourceTextureHandle, srctex))) write_log (_T("%s: SetTexture(srctex) failed: %s\n"), D3DHEAD, D3D_ErrorString (hr)); if (s->m_SourceDimsEffectHandle) { @@ -3081,11 +3105,11 @@ static void D3D_render2 (void) } if (after >= 0) { - if (FAILED (hr = d3ddev->GetRenderTarget (0, &lpRenderTarget))) + if (FAILED (hr = d3d->d3ddev->GetRenderTarget (0, &lpRenderTarget))) write_log (_T("%s: GetRenderTarget: %s\n"), D3DHEAD, D3D_ErrorString (hr)); - if (FAILED (hr = lpPostTempTexture->GetSurfaceLevel (0, &lpNewRenderTarget))) + if (FAILED (hr = d3d->lpPostTempTexture->GetSurfaceLevel (0, &lpNewRenderTarget))) write_log (_T("%s: GetSurfaceLevel: %s\n"), D3DHEAD, D3D_ErrorString (hr)); - if (FAILED (hr = d3ddev->SetRenderTarget (0, lpNewRenderTarget))) + if (FAILED (hr = d3d->d3ddev->SetRenderTarget (0, lpNewRenderTarget))) write_log (_T("%s: SetRenderTarget: %s\n"), D3DHEAD, D3D_ErrorString (hr)); } @@ -3093,7 +3117,7 @@ static void D3D_render2 (void) if (psEffect_Begin (psEffect_None, &uPasses, s)) { for (uPass = 0; uPass < uPasses; uPass++) { if (psEffect_BeginPass (postEffect, uPass)) { - if (FAILED (hr = d3ddev->DrawPrimitive (D3DPT_TRIANGLESTRIP, 0, 2))) + if (FAILED (hr = d3d->d3ddev->DrawPrimitive (D3DPT_TRIANGLESTRIP, 0, 2))) write_log (_T("%s: Post DrawPrimitive failed: %s\n"), D3DHEAD, D3D_ErrorString (hr)); psEffect_EndPass (postEffect); } @@ -3102,17 +3126,17 @@ static void D3D_render2 (void) } if (after >= 0) { - if (FAILED (hr = d3ddev->SetRenderTarget (0, lpRenderTarget))) + if (FAILED (hr = d3d->d3ddev->SetRenderTarget (0, lpRenderTarget))) write_log (_T("%s: SetRenderTarget: %s\n"), D3DHEAD, D3D_ErrorString (hr)); lpNewRenderTarget->Release (); lpRenderTarget->Release (); - srctex = lpPostTempTexture; + srctex = d3d->lpPostTempTexture; for (int i = 0; i < MAX_SHADERS; i++) { - struct shaderdata *s = &shaders[i]; + struct shaderdata *s = &d3d->shaders[i]; if (s->type == SHADERTYPE_AFTER) { - settransform2 (s); - srctex = processshader (srctex, s, i != after); + settransform2 (d3d, s); + srctex = processshader (d3d, srctex, s, i != after); if (!srctex) return; } @@ -3122,57 +3146,57 @@ static void D3D_render2 (void) } else { // non-shader version - setupscenecoords (); - hr = d3ddev->SetTransform (D3DTS_PROJECTION, &m_matProj); - hr = d3ddev->SetTransform (D3DTS_VIEW, &m_matView); - hr = d3ddev->SetTransform (D3DTS_WORLD, &m_matWorld); - hr = d3ddev->SetTexture (0, srctex); - hr = d3ddev->DrawPrimitive (D3DPT_TRIANGLESTRIP, 0, 2); + setupscenecoords (d3d); + hr = d3d->d3ddev->SetTransform (D3DTS_PROJECTION, &d3d->m_matProj); + hr = d3d->d3ddev->SetTransform (D3DTS_VIEW, &d3d->m_matView); + hr = d3d->d3ddev->SetTransform (D3DTS_WORLD, &d3d->m_matWorld); + hr = d3d->d3ddev->SetTexture (0, srctex); + hr = d3d->d3ddev->DrawPrimitive (D3DPT_TRIANGLESTRIP, 0, 2); int bl = filterd3d->gfx_filter_bilinear ? D3DTEXF_LINEAR : D3DTEXF_POINT; - hr = d3ddev->SetSamplerState(0, D3DSAMP_MINFILTER, bl); - hr = d3ddev->SetSamplerState(0, D3DSAMP_MAGFILTER, bl); - hr = d3ddev->SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP); - hr = d3ddev->SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP); + hr = d3d->d3ddev->SetSamplerState(0, D3DSAMP_MINFILTER, bl); + hr = d3d->d3ddev->SetSamplerState(0, D3DSAMP_MAGFILTER, bl); + hr = d3d->d3ddev->SetSamplerState(0, D3DSAMP_ADDRESSU, D3DTADDRESS_CLAMP); + hr = d3d->d3ddev->SetSamplerState(0, D3DSAMP_ADDRESSV, D3DTADDRESS_CLAMP); - if (sprite && sltexture) { + if (d3d->sprite && d3d->sltexture) { D3DXVECTOR3 v; - sprite->Begin (D3DXSPRITE_ALPHABLEND); + d3d->sprite->Begin (D3DXSPRITE_ALPHABLEND); v.x = v.y = v.z = 0; - sprite->Draw (sltexture, NULL, NULL, &v, 0xffffffff); - sprite->End (); + d3d->sprite->Draw (d3d->sltexture, NULL, NULL, &v, 0xffffffff); + d3d->sprite->End (); } } - if (sprite && ((ledtexture) || (mask2texture) || (cursorsurfaced3d && cursor_v))) { + if (d3d->sprite && ((d3d->ledtexture) || (d3d->mask2texture) || (d3d->cursorsurfaced3d && d3d->cursor_v))) { D3DXVECTOR3 v; - sprite->Begin (D3DXSPRITE_ALPHABLEND); - if (cursorsurfaced3d && cursor_v) { + d3d->sprite->Begin (D3DXSPRITE_ALPHABLEND); + if (d3d->cursorsurfaced3d && d3d->cursor_v) { D3DXMATRIXA16 t; - if (cursor_scale) - MatrixScaling (&t, ((float)(window_w) / (tout_w + 2 * cursor_offset2_x)), ((float)(window_h) / (tout_h + 2 * cursor_offset2_y)), 0); + if (d3d->cursor_scale) + MatrixScaling (&t, ((float)(d3d->window_w) / (d3d->tout_w + 2 * d3d->cursor_offset2_x)), ((float)(d3d->window_h) / (d3d->tout_h + 2 * d3d->cursor_offset2_y)), 0); else MatrixScaling (&t, 1.0f, 1.0f, 0); - v.x = cursor_x + cursor_offset2_x; - v.y = cursor_y + cursor_offset2_y; + v.x = d3d->cursor_x + d3d->cursor_offset2_x; + v.y = d3d->cursor_y + d3d->cursor_offset2_y; v.z = 0; - sprite->SetTransform (&t); - sprite->Draw (cursorsurfaced3d, NULL, NULL, &v, 0xffffffff); + d3d->sprite->SetTransform (&t); + d3d->sprite->Draw (d3d->cursorsurfaced3d, NULL, NULL, &v, 0xffffffff); MatrixScaling (&t, 1, 1, 0); - sprite->Flush (); - sprite->SetTransform (&t); + d3d->sprite->Flush (); + d3d->sprite->SetTransform (&t); } - if (mask2texture) { + if (d3d->mask2texture) { D3DXMATRIXA16 t; RECT r; - float srcw = mask2texture_w; - float srch = mask2texture_h; + float srcw = d3d->mask2texture_w; + float srch = d3d->mask2texture_h; float aspectsrc = srcw / srch; - float aspectdst = (float)window_w / window_h; + float aspectdst = (float)d3d->window_w / d3d->window_h; float w, h; - w = mask2texture_multx; - h = mask2texture_multy; + w = d3d->mask2texture_multx; + h = d3d->mask2texture_multy; #if 0 if (currprefs.gfx_filteroverlay_pos.width > 0) w = (float)currprefs.gfx_filteroverlay_pos.width / srcw; @@ -3192,119 +3216,124 @@ static void D3D_render2 (void) v.x = 0; if (filterd3d->gfx_filteroverlay_pos.x == -1) - v.x = (window_w - (mask2texture_w * w)) / 2; + v.x = (d3d->window_w - (d3d->mask2texture_w * w)) / 2; else if (filterd3d->gfx_filteroverlay_pos.x > -24000) v.x = filterd3d->gfx_filteroverlay_pos.x; else - v.x = (window_w - (mask2texture_w * w)) / 2 + (-filterd3d->gfx_filteroverlay_pos.x - 30100) * window_w / 100.0; + v.x = (d3d->window_w - (d3d->mask2texture_w * w)) / 2 + (-filterd3d->gfx_filteroverlay_pos.x - 30100) * d3d->window_w / 100.0; v.y = 0; if (filterd3d->gfx_filteroverlay_pos.y == -1) - v.y = (window_h - (mask2texture_h * h)) / 2; + v.y = (d3d->window_h - (d3d->mask2texture_h * h)) / 2; else if (filterd3d->gfx_filteroverlay_pos.y > -24000) v.y = filterd3d->gfx_filteroverlay_pos.y; else - v.y = (window_h - (mask2texture_h * h)) / 2 + (-filterd3d->gfx_filteroverlay_pos.y - 30100) * window_h / 100.0; + v.y = (d3d->window_h - (d3d->mask2texture_h * h)) / 2 + (-filterd3d->gfx_filteroverlay_pos.y - 30100) * d3d->window_h / 100.0; v.x /= w; v.y /= h; v.x = v.y = 0; v.z = 0; - v.x += mask2texture_offsetw / w; + v.x += d3d->mask2texture_offsetw / w; r.left = 0; r.top = 0; - r.right = mask2texture_w; - r.bottom = mask2texture_h; + r.right = d3d->mask2texture_w; + r.bottom = d3d->mask2texture_h; if (showoverlay) { - sprite->SetTransform (&t); - sprite->Draw (mask2texture, &r, NULL, &v, 0xffffffff); - sprite->Flush (); + d3d->sprite->SetTransform (&t); + d3d->sprite->Draw (d3d->mask2texture, &r, NULL, &v, 0xffffffff); + d3d->sprite->Flush (); } MatrixScaling (&t, 1, 1, 0); - sprite->SetTransform (&t); + d3d->sprite->SetTransform (&t); - if (mask2texture_offsetw > 0) { + if (d3d->mask2texture_offsetw > 0) { v.x = 0; v.y = 0; r.left = 0; r.top = 0; - r.right = mask2texture_offsetw + 1; - r.bottom = window_h; - sprite->Draw (blanktexture, &r, NULL, &v, 0xffffffff); - if (window_w > mask2texture_offsetw + mask2texture_ww) { - v.x = mask2texture_offsetw + mask2texture_ww; + r.right = d3d->mask2texture_offsetw + 1; + r.bottom = d3d->window_h; + d3d->sprite->Draw (d3d->blanktexture, &r, NULL, &v, 0xffffffff); + if (d3d->window_w > d3d->mask2texture_offsetw + d3d->mask2texture_ww) { + v.x = d3d->mask2texture_offsetw + d3d->mask2texture_ww; v.y = 0; r.left = 0; r.top = 0; - r.right = window_w - (mask2texture_offsetw + mask2texture_ww) + 1; - r.bottom = window_h; - sprite->Draw (blanktexture, &r, NULL, &v, 0xffffffff); + r.right = d3d->window_w - (d3d->mask2texture_offsetw + d3d->mask2texture_ww) + 1; + r.bottom = d3d->window_h; + d3d->sprite->Draw (d3d->blanktexture, &r, NULL, &v, 0xffffffff); } } } - if (ledtexture && (((currprefs.leds_on_screen & STATUSLINE_RTG) && WIN32GFX_IsPicassoScreen ()) || ((currprefs.leds_on_screen & STATUSLINE_CHIPSET) && !WIN32GFX_IsPicassoScreen ()))) { + if (d3d->ledtexture && (((currprefs.leds_on_screen & STATUSLINE_RTG) && WIN32GFX_IsPicassoScreen ()) || ((currprefs.leds_on_screen & STATUSLINE_CHIPSET) && !WIN32GFX_IsPicassoScreen ()))) { int slx, sly; - statusline_getpos (&slx, &sly, window_w, window_h, statusbar_hx, statusbar_vx); + statusline_getpos (&slx, &sly, d3d->window_w, d3d->window_h, d3d->statusbar_hx, d3d->statusbar_vx); v.x = slx; v.y = sly; v.z = 0; - sprite->Draw (ledtexture, NULL, NULL, &v, 0xffffffff); + d3d->sprite->Draw (d3d->ledtexture, NULL, NULL, &v, 0xffffffff); } - sprite->End (); + d3d->sprite->End (); } #endif - hr = d3ddev->EndScene (); + hr = d3d->d3ddev->EndScene (); if (FAILED (hr)) write_log (_T("%s: EndScene() %s\n"), D3DHEAD, D3D_ErrorString (hr)); } void D3D_setcursor (int x, int y, int width, int height, bool visible, bool noscale) { + struct d3dstruct *d3d = &d3ddata[0]; + if (width && height) { - cursor_offset2_x = cursor_offset_x * window_w / width; - cursor_offset2_y = cursor_offset_y * window_h / height; - cursor_x = x * window_w / width; - cursor_y = y * window_h / height; + d3d->cursor_offset2_x = d3d->cursor_offset_x * d3d->window_w / width; + d3d->cursor_offset2_y = d3d->cursor_offset_y * d3d->window_h / height; + d3d->cursor_x = x * d3d->window_w / width; + d3d->cursor_y = y * d3d->window_h / height; } else { - cursor_x = cursor_y = 0; - cursor_offset2_x = cursor_offset2_y = 0; + d3d->cursor_x = d3d->cursor_y = 0; + d3d->cursor_offset2_x = d3d->cursor_offset2_y = 0; } - cursor_scale = !noscale; - cursor_v = visible; + d3d->cursor_scale = !noscale; + d3d->cursor_v = visible; } void D3D_unlocktexture (void) { + struct d3dstruct *d3d = &d3ddata[0]; HRESULT hr; - if (!isd3d () || !texture) + if (!isd3d (d3d) || !d3d->texture) return; - if (locked) { + if (d3d->locked) { if (currprefs.leds_on_screen & (STATUSLINE_CHIPSET | STATUSLINE_RTG)) - updateleds (); - hr = texture->UnlockRect (0); + updateleds (d3d); + hr = d3d->texture->UnlockRect (0); } - locked = 0; - fulllocked = 0; + d3d->locked = 0; + d3d->fulllocked = 0; } void D3D_flushtexture (int miny, int maxy) { - if (fakemode || fulllocked || !texture || renderdisabled) + struct d3dstruct *d3d = &d3ddata[0]; + + if (d3d->fakemode || d3d->fulllocked || !d3d->texture || d3d->renderdisabled) return; if (miny >= 0 && maxy >= 0) { RECT r; maxy++; r.left = 0; - r.right = tin_w; + r.right = d3d->tin_w; r.top = miny <= 0 ? 0 : miny; - r.bottom = maxy <= tin_h ? maxy : tin_h; + r.bottom = maxy <= d3d->tin_h ? maxy : d3d->tin_h; if (r.top <= r.bottom) { - HRESULT hr = texture->AddDirtyRect (&r); + HRESULT hr = d3d->texture->AddDirtyRect (&r); if (FAILED (hr)) write_log (_T("%s: AddDirtyRect(): %s\n"), D3DHEAD, D3D_ErrorString (hr)); //write_log (_T("%d %d\n"), r.top, r.bottom); @@ -3314,53 +3343,54 @@ void D3D_flushtexture (int miny, int maxy) uae_u8 *D3D_locktexture (int *pitch, int *height, bool fullupdate) { + struct d3dstruct *d3d = &d3ddata[0]; D3DLOCKED_RECT lock; HRESULT hr; - if (fakemode) { + if (d3d->fakemode) { *pitch = 0; - return fakebitmap; + return d3d->fakebitmap; } - if (D3D_needreset () > 0) { + if (D3D_needreset (d3d) > 0) { return NULL; } - if (!isd3d () || !texture) + if (!isd3d (d3d) || !d3d->texture) return NULL; - if (locked) { + if (d3d->locked) { write_log (_T("%s: texture already locked!\n"), D3DHEAD); return NULL; } lock.pBits = NULL; lock.Pitch = 0; - hr = texture->LockRect (0, &lock, NULL, fullupdate ? D3DLOCK_DISCARD : D3DLOCK_NO_DIRTY_UPDATE); + hr = d3d->texture->LockRect (0, &lock, NULL, fullupdate ? D3DLOCK_DISCARD : D3DLOCK_NO_DIRTY_UPDATE); if (FAILED (hr)) { write_log (_T("%s: LockRect failed: %s\n"), D3DHEAD, D3D_ErrorString (hr)); return NULL; } - locked = 1; + d3d->locked = 1; if (lock.pBits == NULL || lock.Pitch == 0) { write_log (_T("%s: LockRect returned NULL texture\n"), D3DHEAD); D3D_unlocktexture (); return NULL; } - fulllocked = fullupdate; + d3d->fulllocked = fullupdate; *pitch = lock.Pitch; if (height) - *height = tin_h; + *height = d3d->tin_h; return (uae_u8*)lock.pBits; } -static void flushgpu (bool wait) +static void flushgpu (struct d3dstruct *d3d, bool wait) { if (currprefs.turbo_emulation) return; - if (query) { - HRESULT hr = query->Issue (D3DISSUE_END); + if (d3d->query) { + HRESULT hr = d3d->query->Issue (D3DISSUE_END); if (SUCCEEDED (hr)) { - while (query->GetData (NULL, 0, D3DGETDATA_FLUSH) == S_FALSE) { + while (d3d->query->GetData (NULL, 0, D3DGETDATA_FLUSH) == S_FALSE) { if (!wait) return; } @@ -3376,86 +3406,93 @@ static void flushgpu (bool wait) bool D3D_renderframe (bool immediate) { + struct d3dstruct *d3d = &d3ddata[0]; static int vsync2_cnt; - frames_since_init++; + d3d->frames_since_init++; - if (fakemode) + if (d3d->fakemode) return true; - if (!isd3d () || !texture) + if (!isd3d (d3d) || !d3d->texture) return false; - if (filenotificationhandle != NULL) { + if (d3d->filenotificationhandle != NULL) { bool notify = false; - while (WaitForSingleObject (filenotificationhandle, 0) == WAIT_OBJECT_0) { - if (FindNextChangeNotification (filenotificationhandle)) { - if (frames_since_init > 50) + while (WaitForSingleObject (d3d->filenotificationhandle, 0) == WAIT_OBJECT_0) { + if (FindNextChangeNotification (d3d->filenotificationhandle)) { + if (d3d->frames_since_init > 50) notify = true; } } if (notify) { - devicelost = 2; + d3d->devicelost = 2; write_log (_T("%s: Shader file modification notification\n"), D3DHEAD); } } - if (vsync2 > 0) { + if (d3d->vsync2 > 0) { vsync2_cnt ^= 1; if (vsync2_cnt == 0) return true; } - D3D_render2 (); - flushgpu (immediate); + D3D_render2 (d3d); + flushgpu (d3d, immediate); return true; } void D3D_showframe (void) { - if (!isd3d ()) + struct d3dstruct *d3d = &d3ddata[0]; + + if (!isd3d (d3d)) return; if (currprefs.turbo_emulation) { - if ((!(dpp.PresentationInterval & D3DPRESENT_INTERVAL_IMMEDIATE) || variablerefresh) && wasstilldrawing_broken) { + if ((!(d3d->dpp.PresentationInterval & D3DPRESENT_INTERVAL_IMMEDIATE) || d3d->variablerefresh) && d3d->wasstilldrawing_broken) { static int frameskip; if (currprefs.turbo_emulation && frameskip-- > 0) return; frameskip = 10; } - D3D_showframe2 (false); + D3D_showframe2 (d3d, false); } else { - D3D_showframe2 (true); - if (vsync2 == -1 && !currprefs.turbo_emulation) { - D3D_showframe2 (true); + D3D_showframe2 (d3d, true); + if (d3d->vsync2 == -1 && !currprefs.turbo_emulation) { + D3D_showframe2 (d3d ,true); } - flushgpu(true); + flushgpu(d3d, true); } } void D3D_showframe_special (int mode) { + struct d3dstruct *d3d = &d3ddata[0]; + HRESULT hr; - if (!isd3d ()) + if (!isd3d (d3d)) return; if (currprefs.turbo_emulation) return; if (pause_emulation) return; - hr = d3ddev->Clear (0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, d3ddebug ? 0x80 : 0, 0), 0, 0); - D3D_showframe2 (true); - flushgpu (true); + hr = d3d->d3ddev->Clear (0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(0, d3ddebug ? 0x80 : 0, 0), 0, 0); + D3D_showframe2 (d3d, true); + flushgpu (d3d,true); } void D3D_refresh (void) { - if (!isd3d ()) + struct d3dstruct *d3d = &d3ddata[0]; + + if (!isd3d (d3d)) return; - D3D_render2 (); - D3D_showframe2 (true); - D3D_render2 (); - D3D_showframe2 (true); - createscanlines (0); + D3D_render2 (d3d); + D3D_showframe2 (d3d, true); + D3D_render2 (d3d); + D3D_showframe2 (d3d, true); + createscanlines (d3d, 0); } void D3D_getpixelformat (int depth, int *rb, int *gb, int *bb, int *rs, int *gs, int *bs, int *ab, int *as, int *a) @@ -3500,13 +3537,14 @@ void D3D_getpixelformat (int depth, int *rb, int *gb, int *bb, int *rs, int *gs, double D3D_getrefreshrate (void) { + struct d3dstruct *d3d = &d3ddata[0]; HRESULT hr; D3DDISPLAYMODE dmode; - waitfakemode (); - if (!isd3d ()) + waitfakemode (d3d); + if (!isd3d (d3d)) return -1; - hr = d3ddev->GetDisplayMode (0, &dmode); + hr = d3d->d3ddev->GetDisplayMode (0, &dmode); if (FAILED (hr)) return -1; return dmode.RefreshRate; @@ -3514,54 +3552,57 @@ double D3D_getrefreshrate (void) void D3D_guimode (bool guion) { + struct d3dstruct *d3d = &d3ddata[0]; HRESULT hr; - waitfakemode (); - if (!isd3d ()) + waitfakemode (d3d); + if (!isd3d (d3d)) return; - D3D_render2(); - D3D_showframe2(true); - hr = d3ddev->SetDialogBoxMode (guion ? TRUE : FALSE); + D3D_render2(d3d); + D3D_showframe2(d3d, true); + hr = d3d->d3ddev->SetDialogBoxMode (guion ? TRUE : FALSE); if (FAILED (hr)) write_log (_T("%s: SetDialogBoxMode %s\n"), D3DHEAD, D3D_ErrorString (hr)); - guimode = guion; + d3d->guimode = guion; } LPDIRECT3DSURFACE9 D3D_capture(int *w, int *h, int *bits) { + struct d3dstruct *d3d = &d3ddata[0]; LPDIRECT3DSURFACE9 rt; HRESULT hr; - waitfakemode(); - if (!isd3d()) + waitfakemode(d3d); + if (!isd3d(d3d)) return NULL; - hr = d3ddev->GetRenderTarget(0, &rt); + hr = d3d->d3ddev->GetRenderTarget(0, &rt); if (FAILED(hr)) { write_log(_T("%s: GetRenderTarget() failed: %s\n"), D3DHEAD, D3D_ErrorString(hr)); return NULL; } - hr = d3ddev->GetRenderTargetData(rt, screenshotsurface); + hr = d3d->d3ddev->GetRenderTargetData(rt, d3d->screenshotsurface); rt->Release(); if (FAILED(hr)) { write_log(_T("%s: GetRenderTargetData() failed: %s\n"), D3DHEAD, D3D_ErrorString(hr)); return NULL; } - *w = window_w; - *h = window_h; - *bits = t_depth; - return screenshotsurface; + *w = d3d->window_w; + *h = d3d->window_h; + *bits = d3d->t_depth; + return d3d->screenshotsurface; } HDC D3D_getDC (HDC hdc) { + struct d3dstruct *d3d = &d3ddata[0]; static LPDIRECT3DSURFACE9 bb; HRESULT hr; - waitfakemode (); - if (!isd3d ()) + waitfakemode (d3d); + if (!isd3d (d3d)) return 0; if (!hdc) { - hr = d3ddev->GetBackBuffer (0, 0, D3DBACKBUFFER_TYPE_MONO, &bb); + hr = d3d->d3ddev->GetBackBuffer (0, 0, D3DBACKBUFFER_TYPE_MONO, &bb); if (FAILED (hr)) { write_log (_T("%s: GetBackBuffer() failed: %s\n"), D3DHEAD, D3D_ErrorString (hr)); return 0; @@ -3582,7 +3623,14 @@ HDC D3D_getDC (HDC hdc) int D3D_isenabled (void) { - return d3d_enabled; + struct d3dstruct *d3d = &d3ddata[0]; + return d3d->d3d_enabled; +} + +LPDIRECT3DTEXTURE9 D3D_getcursorsurface(void) +{ + struct d3dstruct *d3d = &d3ddata[0]; + return d3d->cursorsurfaced3d; } #endif diff --git a/od-win32/direct3d.h b/od-win32/direct3d.h index 891189ba..f4995776 100644 --- a/od-win32/direct3d.h +++ b/od-win32/direct3d.h @@ -1,4 +1,3 @@ -extern void D3D_resize (int width, int height); extern void D3D_free (bool immediate); extern const TCHAR *D3D_init (HWND ahwnd, int w_w, int h_h, int depth, int *freq, int mmult); extern bool D3D_alloctexture (int, int); @@ -21,8 +20,8 @@ extern bool D3D_getvblankpos (int *vpos); extern double D3D_getrefreshrate (void); extern void D3D_vblank_reset (double freq); extern void D3D_restore (void); -extern LPDIRECT3DTEXTURE9 cursorsurfaced3d; extern LPDIRECT3DSURFACE9 D3D_capture(int*,int*,int*); +extern LPDIRECT3DTEXTURE9 D3D_getcursorsurface(void); #define CURSORMAXWIDTH 64 #define CURSORMAXHEIGHT 64 -- 2.47.3