From 1e13cf99acbdf72ea71e2d626f7f053c6e62985d Mon Sep 17 00:00:00 2001 From: David Rose Date: Wed, 1 Jun 2005 20:44:23 +0000 Subject: [PATCH] pandify --- panda/src/dxgsg8/dxGraphicsStateGuardian8.cxx | 241 ++++++++---------- panda/src/dxgsg8/dxGraphicsStateGuardian8.h | 11 +- panda/src/dxgsg8/dxgsg8base.h | 44 ++-- 3 files changed, 136 insertions(+), 160 deletions(-) diff --git a/panda/src/dxgsg8/dxGraphicsStateGuardian8.cxx b/panda/src/dxgsg8/dxGraphicsStateGuardian8.cxx index 9d72af2483..271e76a634 100644 --- a/panda/src/dxgsg8/dxGraphicsStateGuardian8.cxx +++ b/panda/src/dxgsg8/dxGraphicsStateGuardian8.cxx @@ -68,14 +68,13 @@ TypeHandle DXGraphicsStateGuardian8::_type_handle; -static D3DMATRIX matIdentity; +D3DMATRIX DXGraphicsStateGuardian8::_d3d_ident_mat; + #define __D3DLIGHT_RANGE_MAX ((float)sqrt(FLT_MAX)) //for some reason this is missing in dx8 hdrs #define MY_D3DRGBA(r, g, b, a) ((D3DCOLOR) D3DCOLOR_COLORVALUE(r, g, b, a)) -static bool tex_stats_retrieval_impossible = false; - //////////////////////////////////////////////////////////////////// // Function: DXGraphicsStateGuardian8::Constructor // Access: Public @@ -92,16 +91,16 @@ DXGraphicsStateGuardian8(const FrameBufferProperties &properties) : _transform_stale = false; _vertex_blending_enabled = false; _overlay_windows_supported = false; + _tex_stats_retrieval_impossible = false; _active_vbuffer = NULL; _active_ibuffer = NULL; - // non-dx obj values inited here should not change if resize is - // called and dx objects need to be recreated (otherwise they - // belong in dx_init, with other renderstate - - ZeroMemory(&matIdentity, sizeof(D3DMATRIX)); - matIdentity._11 = matIdentity._22 = matIdentity._33 = matIdentity._44 = 1.0f; + // This is a static member, but we initialize it here in the + // constructor anyway. It won't hurt if it gets repeatedly + // initalized. + ZeroMemory(&_d3d_ident_mat, sizeof(D3DMATRIX)); + _d3d_ident_mat._11 = _d3d_ident_mat._22 = _d3d_ident_mat._33 = _d3d_ident_mat._44 = 1.0f; _cur_read_pixel_buffer = RenderBuffer::T_front; set_color_clear_value(_color_clear_value); @@ -204,55 +203,55 @@ apply_texture(int i, TextureContext *tc) { } Texture *tex = tc->_texture; - Texture::WrapMode wrapU, wrapV; - wrapU = tex->get_wrap_u(); - wrapV = tex->get_wrap_v(); + Texture::WrapMode wrap_u, wrap_v; + wrap_u = tex->get_wrap_u(); + wrap_v = tex->get_wrap_v(); - _pD3DDevice->SetTextureStageState(i, D3DTSS_ADDRESSU, get_texture_wrap_mode(wrapU)); - _pD3DDevice->SetTextureStageState(i, D3DTSS_ADDRESSV, get_texture_wrap_mode(wrapV)); + _pD3DDevice->SetTextureStageState(i, D3DTSS_ADDRESSU, get_texture_wrap_mode(wrap_u)); + _pD3DDevice->SetTextureStageState(i, D3DTSS_ADDRESSV, get_texture_wrap_mode(wrap_v)); uint aniso_degree = tex->get_anisotropic_degree(); Texture::FilterType ft = tex->get_magfilter(); _pD3DDevice->SetTextureStageState(i, D3DTSS_MAXANISOTROPY, aniso_degree); - D3DTEXTUREFILTERTYPE newMagFilter; + D3DTEXTUREFILTERTYPE new_mag_filter; if (aniso_degree <= 1) { - newMagFilter = ((ft != Texture::FT_nearest) ? D3DTEXF_LINEAR : D3DTEXF_POINT); + new_mag_filter = ((ft != Texture::FT_nearest) ? D3DTEXF_LINEAR : D3DTEXF_POINT); } else { - newMagFilter = D3DTEXF_ANISOTROPIC; + new_mag_filter = D3DTEXF_ANISOTROPIC; } - _pD3DDevice->SetTextureStageState(i, D3DTSS_MAGFILTER, newMagFilter); + _pD3DDevice->SetTextureStageState(i, D3DTSS_MAGFILTER, new_mag_filter); // map Panda composite min+mip filter types to d3d's separate min & mip filter types - D3DTEXTUREFILTERTYPE newMinFilter = get_d3d_min_type(tex->get_minfilter()); - D3DTEXTUREFILTERTYPE newMipFilter = get_d3d_mip_type(tex->get_minfilter()); + D3DTEXTUREFILTERTYPE new_min_filter = get_d3d_min_type(tex->get_minfilter()); + D3DTEXTUREFILTERTYPE new_mip_filter = get_d3d_mip_type(tex->get_minfilter()); if (!tex->might_have_ram_image()) { // If the texture is completely dynamic, don't try to issue // mipmaps--pandadx doesn't support auto-generated mipmaps at this // point. - newMipFilter = D3DTEXF_NONE; + new_mip_filter = D3DTEXF_NONE; } #ifndef NDEBUG // sanity check - if ((!dtc->has_mipmaps()) && (newMipFilter != D3DTEXF_NONE)) { + if ((!dtc->has_mipmaps()) && (new_mip_filter != D3DTEXF_NONE)) { dxgsg8_cat.error() << "Trying to set mipmap filtering for texture with no generated mipmaps!! texname[" << tex->get_name() << "], filter(" << tex->get_minfilter() << ")\n"; - newMipFilter = D3DTEXF_NONE; + new_mip_filter = D3DTEXF_NONE; } #endif if (aniso_degree >= 2) { - newMinFilter = D3DTEXF_ANISOTROPIC; + new_min_filter = D3DTEXF_ANISOTROPIC; } - _pD3DDevice->SetTextureStageState(i, D3DTSS_MINFILTER, newMinFilter); - _pD3DDevice->SetTextureStageState(i, D3DTSS_MIPFILTER, newMipFilter); + _pD3DDevice->SetTextureStageState(i, D3DTSS_MINFILTER, new_min_filter); + _pD3DDevice->SetTextureStageState(i, D3DTSS_MIPFILTER, new_mip_filter); _pD3DDevice->SetTexture(i, dtc->get_d3d_texture()); } @@ -265,8 +264,8 @@ apply_texture(int i, TextureContext *tc) { //////////////////////////////////////////////////////////////////// void DXGraphicsStateGuardian8:: release_texture(TextureContext *tc) { - DXTextureContext8 *gtc = DCAST(DXTextureContext8, tc); - delete gtc; + DXTextureContext8 *dtc = DCAST(DXTextureContext8, tc); + delete dtc; } //////////////////////////////////////////////////////////////////// @@ -715,7 +714,6 @@ end_scene() { HRESULT hr = _pD3DDevice->EndScene(); if (FAILED(hr)) { - if (hr == D3DERR_DEVICELOST) { if (dxgsg8_cat.is_debug()) { dxgsg8_cat.debug() @@ -745,11 +743,11 @@ end_frame() { #if defined(DO_PSTATS) if (_texmgrmem_total_pcollector.is_active()) { #define TICKS_PER_GETTEXINFO (2.5*1000) // 2.5 second interval - static DWORD LastTickCount = 0; - DWORD CurTickCount = GetTickCount(); + static DWORD last_tick_count = 0; + DWORD cur_tick_count = GetTickCount(); - if (CurTickCount-LastTickCount > TICKS_PER_GETTEXINFO) { - LastTickCount = CurTickCount; + if (cur_tick_count - last_tick_count > TICKS_PER_GETTEXINFO) { + last_tick_count = cur_tick_count; report_texmgr_stats(); } } @@ -851,7 +849,7 @@ begin_draw_primitives(const qpGeom *geom, const qpGeomMunger *munger, // these vertices, but that turns out to be a bigger hammer than // we want: that also prevents lighting calculations and user clip // planes. - _pD3DDevice->SetTransform(D3DTS_WORLD, &matIdentity); + _pD3DDevice->SetTransform(D3DTS_WORLD, &_d3d_ident_mat); static const LMatrix4f rescale_mat (1, 0, 0, 0, 0, 1, 0, 0, @@ -1323,17 +1321,17 @@ framebuffer_copy_to_texture(Texture *tex, int z, const DisplayRegion *dr, const } DXTextureContext8 *dtc = DCAST(DXTextureContext8, tc); - IDirect3DSurface8 *pTexSurfaceLev0, *pCurRenderTarget; - hr = dtc->get_d3d_texture()->GetSurfaceLevel(0, &pTexSurfaceLev0); + IDirect3DSurface8 *tex_level_0, *render_target; + hr = dtc->get_d3d_texture()->GetSurfaceLevel(0, &tex_level_0); if (FAILED(hr)) { dxgsg8_cat.error() << "GetSurfaceLev failed in copy_texture" << D3DERRORSTRING(hr); return; } - hr = _pD3DDevice->GetRenderTarget(&pCurRenderTarget); + hr = _pD3DDevice->GetRenderTarget(&render_target); if (FAILED(hr)) { dxgsg8_cat.error() << "GetRenderTgt failed in copy_texture" << D3DERRORSTRING(hr); - SAFE_RELEASE(pTexSurfaceLev0); + SAFE_RELEASE(tex_level_0); return; } @@ -1345,14 +1343,14 @@ framebuffer_copy_to_texture(Texture *tex, int z, const DisplayRegion *dr, const SrcRect.bottom = yo+h; // now copy from fb to tex - hr = _pD3DDevice->CopyRects(pCurRenderTarget, &SrcRect, 1, pTexSurfaceLev0, 0); + hr = _pD3DDevice->CopyRects(render_target, &SrcRect, 1, tex_level_0, 0); if (FAILED(hr)) { dxgsg8_cat.error() << "CopyRects failed in copy_texture" << D3DERRORSTRING(hr); } - SAFE_RELEASE(pCurRenderTarget); - SAFE_RELEASE(pTexSurfaceLev0); + SAFE_RELEASE(render_target); + SAFE_RELEASE(tex_level_0); } @@ -1370,7 +1368,7 @@ bool DXGraphicsStateGuardian8:: framebuffer_copy_to_ram(Texture *tex, int z, const DisplayRegion *dr, const RenderBuffer &rb) { set_read_buffer(rb); - RECT SrcCopyRect; + RECT rect; nassertr(tex != NULL && dr != NULL, false); int xo, yo, w, h; @@ -1378,29 +1376,32 @@ framebuffer_copy_to_ram(Texture *tex, int z, const DisplayRegion *dr, const Rend tex->setup_2d_texture(w, h, Texture::T_unsigned_byte, Texture::F_rgb); - SrcCopyRect.top = yo; - SrcCopyRect.left = xo; - SrcCopyRect.right = xo + w; - SrcCopyRect.bottom = yo + h; + rect.top = yo; + rect.left = xo; + rect.right = xo + w; + rect.bottom = yo + h; - IDirect3DSurface8 *pD3DSurf; + IDirect3DSurface8 *framebuffer; HRESULT hr; if (_cur_read_pixel_buffer & RenderBuffer::T_back) { - hr = _pD3DDevice->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &pD3DSurf); + hr = _pD3DDevice->GetBackBuffer(0, D3DBACKBUFFER_TYPE_MONO, &framebuffer); if (FAILED(hr)) { dxgsg8_cat.error() << "GetBackBuffer failed" << D3DERRORSTRING(hr); return false; } - // note if you try to grab the backbuffer and full-screen anti-aliasing is on, - // the backbuffer might be larger than the window size. for screenshots its safer to get the front buffer. + // note if you try to grab the backbuffer and full-screen + // anti-aliasing is on, the backbuffer might be larger than the + // window size. for screenshots its safer to get the front + // buffer. } else if (_cur_read_pixel_buffer & RenderBuffer::T_front) { - // must create a A8R8G8B8 sysmem surface for GetFrontBuffer to copy to + // must create a A8R8G8B8 sysmem surface for GetFrontBuffer to + // copy to - DWORD TmpSurfXsize, TmpSurfYsize; + DWORD temp_x_size, temp_y_size; if (_pScrn->PresParams.Windowed) { // GetFrontBuffer retrieves the entire desktop for a monitor, so @@ -1410,30 +1411,30 @@ framebuffer_copy_to_ram(Texture *tex, int z, const DisplayRegion *dr, const Rend minfo.cbSize = sizeof(MONITORINFO); GetMonitorInfo(_pScrn->hMon, &minfo); // have to use GetMonitorInfo, since this gsg may not be for primary monitor - TmpSurfXsize = RECT_XSIZE(minfo.rcMonitor); - TmpSurfYsize = RECT_YSIZE(minfo.rcMonitor); + temp_x_size = RECT_XSIZE(minfo.rcMonitor); + temp_y_size = RECT_YSIZE(minfo.rcMonitor); - // set SrcCopyRect to client area of window in scrn coords - ClientToScreen(_pScrn->hWnd, (POINT*)&SrcCopyRect.left); - ClientToScreen(_pScrn->hWnd, (POINT*)&SrcCopyRect.right); + // set rect to client area of window in scrn coords + ClientToScreen(_pScrn->hWnd, (POINT*)&rect.left); + ClientToScreen(_pScrn->hWnd, (POINT*)&rect.right); } else { - RECT WindRect; - GetWindowRect(_pScrn->hWnd, &WindRect); - TmpSurfXsize = RECT_XSIZE(WindRect); - TmpSurfYsize = RECT_YSIZE(WindRect); + RECT wind_rect; + GetWindowRect(_pScrn->hWnd, &wind_rect); + temp_x_size = RECT_XSIZE(wind_rect); + temp_y_size = RECT_YSIZE(wind_rect); } - hr = _pD3DDevice->CreateImageSurface(TmpSurfXsize, TmpSurfYsize, D3DFMT_A8R8G8B8, &pD3DSurf); + hr = _pD3DDevice->CreateImageSurface(temp_x_size, temp_y_size, D3DFMT_A8R8G8B8, &framebuffer); if (FAILED(hr)) { dxgsg8_cat.error() << "CreateImageSurface failed in copy_pixel_buffer()" << D3DERRORSTRING(hr); return false; } - hr = _pD3DDevice->GetFrontBuffer(pD3DSurf); + hr = _pD3DDevice->GetFrontBuffer(framebuffer); if (hr == D3DERR_DEVICELOST) { - pD3DSurf->Release(); + framebuffer->Release(); dxgsg8_cat.error() << "copy_pixel_buffer failed: device lost\n"; return false; } @@ -1443,9 +1444,9 @@ framebuffer_copy_to_ram(Texture *tex, int z, const DisplayRegion *dr, const Rend return false; } - DXTextureContext8::d3d_surface_to_texture(SrcCopyRect, pD3DSurf, tex); + DXTextureContext8::d3d_surface_to_texture(rect, framebuffer, tex); - RELEASE(pD3DSurf, dxgsg8, "pD3DSurf", RELEASE_ONCE); + RELEASE(framebuffer, dxgsg8, "framebuffer", RELEASE_ONCE); nassertr(tex->has_ram_image(), false); return true; @@ -1481,36 +1482,36 @@ reset() { assert(_pScrn->pD3D8 != NULL); assert(_pD3DDevice != NULL); - D3DCAPS8 d3dCaps; - _pD3DDevice->GetDeviceCaps(&d3dCaps); + D3DCAPS8 d3d_caps; + _pD3DDevice->GetDeviceCaps(&d3d_caps); if (dxgsg8_cat.is_debug()) { dxgsg8_cat.debug() - << "\nHwTransformAndLight = " << ((d3dCaps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT) != 0) - << "\nMaxTextureWidth = " << d3dCaps.MaxTextureWidth - << "\nMaxTextureHeight = " << d3dCaps.MaxTextureHeight - << "\nMaxVolumeExtent = " << d3dCaps.MaxVolumeExtent - << "\nMaxTextureAspectRatio = " << d3dCaps.MaxTextureAspectRatio - << "\nTexCoordCount = " << (d3dCaps.FVFCaps & D3DFVFCAPS_TEXCOORDCOUNTMASK) - << "\nMaxTextureBlendStages = " << d3dCaps.MaxTextureBlendStages - << "\nMaxSimultaneousTextures = " << d3dCaps.MaxSimultaneousTextures - << "\nMaxActiveLights = " << d3dCaps.MaxActiveLights - << "\nMaxUserClipPlanes = " << d3dCaps.MaxUserClipPlanes - << "\nMaxVertexBlendMatrices = " << d3dCaps.MaxVertexBlendMatrices - << "\nMaxVertexBlendMatrixIndex = " << d3dCaps.MaxVertexBlendMatrixIndex - << "\nMaxPointSize = " << d3dCaps.MaxPointSize - << "\nMaxPrimitiveCount = " << d3dCaps.MaxPrimitiveCount - << "\nMaxVertexIndex = " << d3dCaps.MaxVertexIndex - << "\nMaxStreams = " << d3dCaps.MaxStreams - << "\nMaxStreamStride = " << d3dCaps.MaxStreamStride + << "\nHwTransformAndLight = " << ((d3d_caps.DevCaps & D3DDEVCAPS_HWTRANSFORMANDLIGHT) != 0) + << "\nMaxTextureWidth = " << d3d_caps.MaxTextureWidth + << "\nMaxTextureHeight = " << d3d_caps.MaxTextureHeight + << "\nMaxVolumeExtent = " << d3d_caps.MaxVolumeExtent + << "\nMaxTextureAspectRatio = " << d3d_caps.MaxTextureAspectRatio + << "\nTexCoordCount = " << (d3d_caps.FVFCaps & D3DFVFCAPS_TEXCOORDCOUNTMASK) + << "\nMaxTextureBlendStages = " << d3d_caps.MaxTextureBlendStages + << "\nMaxSimultaneousTextures = " << d3d_caps.MaxSimultaneousTextures + << "\nMaxActiveLights = " << d3d_caps.MaxActiveLights + << "\nMaxUserClipPlanes = " << d3d_caps.MaxUserClipPlanes + << "\nMaxVertexBlendMatrices = " << d3d_caps.MaxVertexBlendMatrices + << "\nMaxVertexBlendMatrixIndex = " << d3d_caps.MaxVertexBlendMatrixIndex + << "\nMaxPointSize = " << d3d_caps.MaxPointSize + << "\nMaxPrimitiveCount = " << d3d_caps.MaxPrimitiveCount + << "\nMaxVertexIndex = " << d3d_caps.MaxVertexIndex + << "\nMaxStreams = " << d3d_caps.MaxStreams + << "\nMaxStreamStride = " << d3d_caps.MaxStreamStride << "\n"; } - _max_texture_stages = d3dCaps.MaxSimultaneousTextures; - _max_lights = d3dCaps.MaxActiveLights; - _max_clip_planes = d3dCaps.MaxUserClipPlanes; - _max_vertex_transforms = d3dCaps.MaxVertexBlendMatrices; - _max_vertex_transform_indices = d3dCaps.MaxVertexBlendMatrixIndex; + _max_texture_stages = d3d_caps.MaxSimultaneousTextures; + _max_lights = d3d_caps.MaxActiveLights; + _max_clip_planes = d3d_caps.MaxUserClipPlanes; + _max_vertex_transforms = d3d_caps.MaxVertexBlendMatrices; + _max_vertex_transform_indices = d3d_caps.MaxVertexBlendMatrixIndex; ZeroMemory(&_lmodel_ambient, sizeof(Colorf)); _pD3DDevice->SetRenderState(D3DRS_AMBIENT, 0x0); @@ -1522,7 +1523,7 @@ reset() { // these both reflect d3d defaults _color_writemask = 0xFFFFFFFF; - _CurFVFType = 0x0; // guards SetVertexShader fmt + _CurFVFType = 0x0; _pD3DDevice->SetRenderState(D3DRS_SHADEMODE, D3DSHADE_GOURAUD); @@ -1573,15 +1574,18 @@ reset() { _pScrn->d3dcaps.MaxTextureHeight = 256; if (_pScrn->d3dcaps.RasterCaps & D3DPRASTERCAPS_FOGTABLE) { - // watch out for drivers that emulate per-pixel fog with per-vertex fog (Riva128, Matrox Millen G200) - // some of these require gouraud-shading to be set to work, as if you were using vertex fog + // Watch out for drivers that emulate per-pixel fog with + // per-vertex fog (Riva128, Matrox Millen G200). Some of these + // require gouraud-shading to be set to work, as if you were using + // vertex fog _doFogType = PerPixelFog; } else { - // every card is going to have vertex fog, since it's implemented in d3d runtime + // every card is going to have vertex fog, since it's implemented + // in d3d runtime. assert((_pScrn->d3dcaps.RasterCaps & D3DPRASTERCAPS_FOGVERTEX) != 0); - // vtx fog may look crappy if you have large polygons in the foreground and they get clipped, - // so you may want to disable it + // vertex fog may look crappy if you have large polygons in the + // foreground and they get clipped, so you may want to disable it if (dx_no_vertex_fog) { _doFogType = None; @@ -1589,14 +1593,15 @@ reset() { _doFogType = PerVertexFog; // range-based fog only works with vertex fog in dx7/8 - if (dx_use_rangebased_fog && (_pScrn->d3dcaps.RasterCaps & D3DPRASTERCAPS_FOGRANGE)) + if (dx_use_rangebased_fog && (_pScrn->d3dcaps.RasterCaps & D3DPRASTERCAPS_FOGRANGE)) { _pD3DDevice->SetRenderState(D3DRS_RANGEFOGENABLE, true); + } } } _pScrn->bCanDirectDisableColorWrites = ((_pScrn->d3dcaps.PrimitiveMiscCaps & D3DPMISCCAPS_COLORWRITEENABLE) != 0); - // Lighting, let's turn it off by default + // Lighting, let's turn it off initially. _pD3DDevice->SetRenderState(D3DRS_LIGHTING, false); // turn on dithering if the rendertarget is < 8bits/color channel @@ -1656,7 +1661,6 @@ reset() { //////////////////////////////////////////////////////////////////// void DXGraphicsStateGuardian8:: apply_fog(Fog *fog) { - if (_doFogType == None) return; @@ -1728,8 +1732,9 @@ issue_alpha_test(const AlphaTestAttrib *attrib) { AlphaTestAttrib::PandaCompareFunc mode = attrib->get_mode(); if (mode == AlphaTestAttrib::M_none) { enable_alpha_test(false); + } else { - // AlphaTestAttrib::PandaCompareFunc == = D3DCMPFUNC + // AlphaTestAttrib::PandaCompareFunc === D3DCMPFUNC call_dxAlphaFunc((D3DCMPFUNC)mode, attrib->get_reference_alpha()); enable_alpha_test(true); } @@ -2275,7 +2280,7 @@ do_issue_texture() { // For some reason, "disabling" texture coordinate transforms // doesn't seem to be sufficient. We'll load an identity matrix // to underscore the point. - _pD3DDevice->SetTransform(get_tex_mat_sym(i), &matIdentity); + _pD3DDevice->SetTransform(get_tex_mat_sym(i), &_d3d_ident_mat); } } @@ -2567,36 +2572,6 @@ set_read_buffer(const RenderBuffer &rb) { return; } -//////////////////////////////////////////////////////////////////// -// Function: DXGraphicsStateGuardian8::get_smooth_state -// Access: Protected, Static -// Description: Returns a RenderState object that represents -// smooth, per-vertex shading. -//////////////////////////////////////////////////////////////////// -CPT(RenderState) DXGraphicsStateGuardian8:: -get_smooth_state() { - static CPT(RenderState) state; - if (state == (RenderState *)NULL) { - state = RenderState::make(ShadeModelAttrib::make(ShadeModelAttrib::M_smooth)); - } - return state; -} - -//////////////////////////////////////////////////////////////////// -// Function: DXGraphicsStateGuardian8::get_flat_state -// Access: Protected, Static -// Description: Returns a RenderState object that represents -// flat, per-primitive shading. -//////////////////////////////////////////////////////////////////// -CPT(RenderState) DXGraphicsStateGuardian8:: -get_flat_state() { - static CPT(RenderState) state; - if (state == (RenderState *)NULL) { - state = RenderState::make(ShadeModelAttrib::make(ShadeModelAttrib::M_flat)); - } - return state; -} - //////////////////////////////////////////////////////////////////// // Function: DXGraphicsStateGuardian8::do_auto_rescale_normal // Access: Protected @@ -2736,7 +2711,7 @@ report_texmgr_stats() { D3DDEVINFO_RESOURCEMANAGER all_resource_stats; ZeroMemory(&all_resource_stats, sizeof(D3DDEVINFO_RESOURCEMANAGER)); - if (!tex_stats_retrieval_impossible) { + if (!_tex_stats_retrieval_impossible) { hr = _pD3DDevice->GetInfo(D3DDEVINFOID_RESOURCEMANAGER, &all_resource_stats, sizeof(D3DDEVINFO_RESOURCEMANAGER)); if (hr != D3D_OK) { if (hr == S_FALSE) { @@ -2747,7 +2722,7 @@ report_texmgr_stats() { << "texstats GetInfo() requires debug DX DLLs to be installed!!\n"; } ZeroMemory(&all_resource_stats, sizeof(D3DDEVINFO_RESOURCEMANAGER)); - tex_stats_retrieval_impossible = true; + _tex_stats_retrieval_impossible = true; } } else { dxgsg8_cat.error() << "GetInfo(RESOURCEMANAGER) failed to get tex stats: result = " << D3DERRORSTRING(hr); diff --git a/panda/src/dxgsg8/dxGraphicsStateGuardian8.h b/panda/src/dxgsg8/dxGraphicsStateGuardian8.h index adf7813388..4e2ddb10a3 100644 --- a/panda/src/dxgsg8/dxGraphicsStateGuardian8.h +++ b/panda/src/dxgsg8/dxGraphicsStateGuardian8.h @@ -133,15 +133,12 @@ protected: virtual void set_blend_mode(); - void free_nondx_resources(); // free local internal buffers + void free_nondx_resources(); void free_d3d_device(void); void set_draw_buffer(const RenderBuffer &rb); void set_read_buffer(const RenderBuffer &rb); - static CPT(RenderState) get_smooth_state(); - static CPT(RenderState) get_flat_state(); - void do_auto_rescale_normal(); protected: @@ -171,7 +168,8 @@ protected: void set_texture_blend_mode(int i, const TextureStage *stage); void dx_cleanup(); - HRESULT reset_d3d_device(D3DPRESENT_PARAMETERS *pPresParams, DXScreenData **pScrn=NULL); + HRESULT reset_d3d_device(D3DPRESENT_PARAMETERS *pPresParams, + DXScreenData **pScrn = NULL); bool check_cooperative_level(); @@ -247,6 +245,9 @@ protected: const DXIndexBufferContext8 *_active_ibuffer; bool _overlay_windows_supported; + bool _tex_stats_retrieval_impossible; + + static D3DMATRIX _d3d_ident_mat; public: virtual TypeHandle get_type() const { diff --git a/panda/src/dxgsg8/dxgsg8base.h b/panda/src/dxgsg8/dxgsg8base.h index c48fa4ec39..8d1f29b0df 100644 --- a/panda/src/dxgsg8/dxgsg8base.h +++ b/panda/src/dxgsg8/dxgsg8base.h @@ -185,28 +185,28 @@ typedef enum { #define RECT_XSIZE(REC) (REC.right-REC.left) #define RECT_YSIZE(REC) (REC.bottom-REC.top) -typedef struct { - LPDIRECT3DDEVICE8 pD3DDevice; - IDirect3DSwapChain8 *pSwapChain; - LPDIRECT3D8 pD3D8; // copied from DXGraphicsPipe8 for convenience - HWND hWnd; - HMONITOR hMon; - DWORD MaxAvailVidMem; - ushort CardIDNum; // adapter ID - ushort depth_buffer_bitdepth; //GetSurfaceDesc is not reliable so must store this explicitly - bool bCanDirectDisableColorWrites; // if true, dont need blending for this - bool bIsLowVidMemCard; - bool bIsTNLDevice; - bool bCanUseHWVertexShaders; - bool bCanUsePixelShaders; - bool bIsDX81; - UINT SupportedScreenDepthsMask; - UINT SupportedTexFmtsMask; - D3DCAPS8 d3dcaps; - D3DDISPLAYMODE DisplayMode; - D3DPRESENT_PARAMETERS PresParams; // not redundant with DisplayMode since width/height must be 0 for windowed mode - D3DADAPTER_IDENTIFIER8 DXDeviceID; -} DXScreenData; +struct DXScreenData { + LPDIRECT3DDEVICE8 pD3DDevice; + IDirect3DSwapChain8 *pSwapChain; + LPDIRECT3D8 pD3D8; // copied from DXGraphicsPipe8 for convenience + HWND hWnd; + HMONITOR hMon; + DWORD MaxAvailVidMem; + ushort CardIDNum; // adapter ID + ushort depth_buffer_bitdepth; //GetSurfaceDesc is not reliable so must store this explicitly + bool bCanDirectDisableColorWrites; // if true, dont need blending for this + bool bIsLowVidMemCard; + bool bIsTNLDevice; + bool bCanUseHWVertexShaders; + bool bCanUsePixelShaders; + bool bIsDX81; + UINT SupportedScreenDepthsMask; + UINT SupportedTexFmtsMask; + D3DCAPS8 d3dcaps; + D3DDISPLAYMODE DisplayMode; + D3DPRESENT_PARAMETERS PresParams; // not redundant with DisplayMode since width/height must be 0 for windowed mode + D3DADAPTER_IDENTIFIER8 DXDeviceID; +}; //utility stuff