TheCloud/panda3d
1
0
Fork 0
mirror of https://github.com/panda3d/panda3d.git synced 2025-10-03 10:22:45 -04:00
Code Issues Packages Projects Releases Wiki Activity

add resize() fullscrn support, more stenciling support

Browse Source
This commit is contained in:
cxgeorge 2001-10-13 23:00:23 +00:00
parent 6921f04120
commit 1e37df2ff2
8 changed files with 908 additions and 618 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

145
panda/src/dxgsg/dxGraphicsStateGuardian.I
View File

@ -19,43 +19,6 @@
#include "config_dxgsg.h"
#include <graphicsWindow.h>
////////////////////////////////////////////////////////////////////
// Function: DXGraphicsStateGuardian::set_pack_alignment
// Access:
// Description:
////////////////////////////////////////////////////////////////////
INLINE void DXGraphicsStateGuardian::
set_pack_alignment(int alignment) {
#ifdef NDEBUG
dxgsg_cat.error() << "set_pack_alignment() unimplemented, has no meaning in DX\n";
#endif
}
////////////////////////////////////////////////////////////////////
// Function: DXGraphicsStateGuardian::set_unpack_alignment
// Access:
// Description:
////////////////////////////////////////////////////////////////////
INLINE void DXGraphicsStateGuardian::
set_unpack_alignment(int alignment) {
#ifdef NDEBUG
dxgsg_cat.error() << "set_unpack_alignment() unimplemented, has no meaning in DX\n";
#endif
}
////////////////////////////////////////////////////////////////////
// Function: DXGraphicsStateGuardian::enable_multisample
// Access:
// Description:
////////////////////////////////////////////////////////////////////
INLINE void DXGraphicsStateGuardian::
enable_multisample(bool val) {
_multisample_enabled = val;
#ifdef NDEBUG
dxgsg_cat.error() << "dx multisample unimplemented!!\n";
#endif
}
////////////////////////////////////////////////////////////////////
// Function: DXGraphicsStateGuardian::enable_line_smooth
// Access:
@ -76,20 +39,6 @@ enable_line_smooth(bool val) {
}
}
////////////////////////////////////////////////////////////////////
// Function: DXGraphicsStateGuardian::enable_point_smooth
// Access:
// Description:
////////////////////////////////////////////////////////////////////
INLINE void DXGraphicsStateGuardian::
enable_point_smooth(bool val) {
_point_smooth_enabled = val;
#ifdef NDEBUG
dxgsg_cat.error() << "dx point smoothing unimplemented!!\n";
#endif
}
////////////////////////////////////////////////////////////////////
// Function: DXGraphicsStateGuardian::enable_lighting
// Access:
@ -122,7 +71,6 @@ enable_dither(bool val) {
#endif
_dither_enabled = val;
_d3dDevice->SetRenderState(D3DRENDERSTATE_DITHERENABLE, (DWORD)val);
}
}
@ -173,32 +121,6 @@ enable_clip_plane(int clip_plane, bool val)
}
}
////////////////////////////////////////////////////////////////////
// Function: DXGraphicsStateGuardian::enable_multisample_alpha_one
// Access:
// Description:
////////////////////////////////////////////////////////////////////
INLINE void DXGraphicsStateGuardian::
enable_multisample_alpha_one(bool val) {
if (_multisample_alpha_one_enabled != val) {
_multisample_alpha_one_enabled = val;
}
}
////////////////////////////////////////////////////////////////////
// Function: DXGraphicsStateGuardian::enable_multisample_alpha_mask
// Access:
// Description:
////////////////////////////////////////////////////////////////////
INLINE void DXGraphicsStateGuardian::
enable_multisample_alpha_mask(bool val) {
if (_multisample_alpha_mask_enabled != val) {
_multisample_alpha_mask_enabled = val;
}
}
////////////////////////////////////////////////////////////////////
// Function: DXGraphicsStateGuardian::enable_blend
// Access:
@ -225,15 +147,6 @@ set_shademode(D3DSHADEMODE val) {
}
}
INLINE void DXGraphicsStateGuardian::
SetDeviceTexture(LPDIRECTDRAWSURFACE7 pTexture) {
// this fn is useful because GetTexture() does an AddRef, so faster to cache it ourself
if (_pCurDeviceTexture != pTexture) {
_pCurDeviceTexture = pTexture;
_d3dDevice->SetTexture(0,_pCurDeviceTexture);
}
}
////////////////////////////////////////////////////////////////////
// Function: DXGraphicsStateGuardian::enable_fog
// Access:
@ -272,8 +185,7 @@ call_dxLightModelAmbient( const Colorf& color)
if (_lmodel_ambient != color) {
_lmodel_ambient = color;
#ifdef GSG_VERBOSE
dxgsg_cat.debug()
<< "glLightModel(GL_LIGHT_MODEL_AMBIENT, " << color << ")" << endl;
dxgsg_cat.debug() << "dxLightModel(LIGHT_MODEL_AMBIENT, " << color << ")" << endl;
#endif
_d3dDevice->SetRenderState( D3DRENDERSTATE_AMBIENT,
D3DRGBA(color[0], color[1], color[2], color[3]));
@ -414,3 +326,58 @@ call_dxBlendFunc(D3DBLEND sfunc, D3DBLEND dfunc )
}
}
/** unimplemented
////////////////////////////////////////////////////////////////////
// Function: DXGraphicsStateGuardian::enable_multisample
// Access:
// Description:
////////////////////////////////////////////////////////////////////
INLINE void DXGraphicsStateGuardian::
enable_multisample(bool val) {
_multisample_enabled = val;
#ifdef NDEBUG
dxgsg_cat.error() << "dx multisample unimplemented!!\n";
#endif
}
////////////////////////////////////////////////////////////////////
// Function: DXGraphicsStateGuardian::enable_multisample_alpha_one
// Access:
// Description:
////////////////////////////////////////////////////////////////////
INLINE void DXGraphicsStateGuardian::
enable_multisample_alpha_one(bool val) {
if (_multisample_alpha_one_enabled != val) {
_multisample_alpha_one_enabled = val;
}
}
////////////////////////////////////////////////////////////////////
// Function: DXGraphicsStateGuardian::enable_multisample_alpha_mask
// Access:
// Description:
////////////////////////////////////////////////////////////////////
INLINE void DXGraphicsStateGuardian::
enable_multisample_alpha_mask(bool val) {
if (_multisample_alpha_mask_enabled != val) {
_multisample_alpha_mask_enabled = val;
}
}
////////////////////////////////////////////////////////////////////
// Function: DXGraphicsStateGuardian::enable_point_smooth
// Access:
// Description:
////////////////////////////////////////////////////////////////////
INLINE void DXGraphicsStateGuardian::
enable_point_smooth(bool val) {
// _point_smooth_enabled = val;
#ifdef NDEBUG
dxgsg_cat.error() << "dx point smoothing unimplemented!!\n";
#endif
}
*/

394
panda/src/dxgsg/dxGraphicsStateGuardian.cxx
View File

@ -109,6 +109,7 @@ TypeHandle DXGraphicsStateGuardian::_type_handle;
static D3DMATRIX matIdentity;
#ifdef COUNT_DRAWPRIMS
// you should just use Intel GPT instead of this stuff
static DWORD cDPcount=0;
static DWORD cVertcount=0;
@ -124,7 +125,7 @@ static void CountDPs(DWORD nVerts,DWORD nTris) {
cVertcount+=nVerts;
cTricount+=nTris;
if(_pCurDeviceTexture==pLastTexture) {
if(_pCurDeviceTexture==pLastTexture) {
cDP_noTexChangeCount++;
} else pLastTexture = _pCurDeviceTexture;
}
@ -139,20 +140,17 @@ static bool bTexStatsRetrievalImpossible=false;
//#define Colorf_to_D3DCOLOR(out_color) (D3DRGBA((out_color)[0], (out_color)[1], (out_color)[2], (out_color)[3]))
INLINE DWORD
Colorf_to_D3DCOLOR(Colorf &cColorf) {
Colorf_to_D3DCOLOR(const Colorf &cColorf) {
// MS VC defines _M_IX86 for x86. gcc should define _X86_
#if defined(_M_IX86) || defined(_X86_)
DWORD d3dcolor,tempcolorval=255;
// DWORD *Colorf_addr=(DWORD*)&cColorf;
// note the default FPU rounding mode will give 255*0.5f=0x80, not 0x7F as VC would force it to by resetting rounding mode
// dont think this makes much difference
__asm {
; push eax
push ebx ; want to save this in case this fn is inlined
push ecx
; mov ecx, Colorf_addr ; must be a better way to do this w/o using ecx
mov ecx, cColorf
fild tempcolorval
fld [ecx]
@ -185,16 +183,21 @@ Colorf_to_D3DCOLOR(Colorf &cColorf) {
mov d3dcolor,eax
pop ecx
pop ebx
; pop eax
}
// dxgsg_cat.debug() << (void*)d3dcolor << endl;
// dxgsg_cat.debug() << (void*)d3dcolor << endl;
return d3dcolor;
#else //!_X86_
return D3DRGBA(cColorf[0], cColorf[1], cColorf[2], cColorf[3]);
#endif //!_X86_
}
void DXGraphicsStateGuardian::
set_color_clear_value(const Colorf& value) {
_color_clear_value = value;
_d3dcolor_clear_value = Colorf_to_D3DCOLOR(value);
}
void DXGraphicsStateGuardian::SetFPSMeterPosition(RECT &view_rect) {
if(_fpsmeter_verts==NULL)
return;
@ -278,7 +281,7 @@ void DXGraphicsStateGuardian::FillFPSMeterTexture(void) {
ZeroMemory(ddsd.lpSurface,ddsd.dwWidth*ddsd.dwHeight*2);
_fpsmeter_font_surf->Unlock(NULL);
// draw text using GDI
// draw FPS text using GDI
HDC hDC;
if(FAILED( hr = _fpsmeter_font_surf->GetDC(&hDC))) {
dxgsg_cat.error() << "fps meter creation failed, GetDC failed on fps font surface! hr = " << ConvD3DErrorToString(hr) << "\n";
@ -340,33 +343,28 @@ void DXGraphicsStateGuardian::FillFPSMeterTexture(void) {
////////////////////////////////////////////////////////////////////
DXGraphicsStateGuardian::
DXGraphicsStateGuardian(GraphicsWindow *win) : GraphicsStateGuardian(win) {
_light_enabled = (bool *)NULL;
_cur_light_enabled = (bool *)NULL;
_clip_plane_enabled = (bool *)NULL;
_cur_clip_plane_enabled = (bool *)NULL;
// allocate local buffers used during rendering
GraphicsStateGuardian::reset();
_pCurFvfBufPtr = NULL;
_pFvfBufBasePtr = new char[VERT_BUFFER_SIZE]; // allocate storage for vertex info.
_index_buf = new WORD[D3DMAXNUMVERTICES]; // allocate storage for vertex index info.
_fpsmeter_verts=NULL;
_fpsmeter_font_surf=NULL;
_dx_ready = false;
_pCurDeviceTexture = NULL;
_CurShadeMode = D3DSHADE_FLAT;
_pri = _zbuf = _back = NULL;
_pDD = NULL;
_d3dDevice = NULL;
_cur_read_pixel_buffer=RenderBuffer::T_front;
// 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;
_cNumTexPixFmts = 0;
_pTexPixFmts = NULL;
_pCurTexContext = NULL;
// Create a default RenderTraverser.
if (dx_cull_traversal) {
_render_traverser = new CullTraverser(this, RenderRelation::get_class_type());
@ -374,14 +372,21 @@ DXGraphicsStateGuardian(GraphicsWindow *win) : GraphicsStateGuardian(win) {
_render_traverser = new DirectRenderTraverser(this, RenderRelation::get_class_type());
}
//Color and alpha transform variables
_color_transform_enabled = false;
_alpha_transform_enabled = false;
_current_color_mat = LMatrix4f::ident_mat();
_current_alpha_offset = 0;
_current_alpha_scale = 1;
// All implementations have the following buffers.
_buffer_mask = (RenderBuffer::T_color |
RenderBuffer::T_depth |
RenderBuffer::T_back
// RenderBuffer::T_stencil |
// RenderBuffer::T_accum
);
reset();
// this is incorrect for general mono displays, need both right and left flags set.
// stereo has not been handled yet for dx
// _buffer_mask &= ~RenderBuffer::T_right;
_cur_read_pixel_buffer=RenderBuffer::T_front;
set_color_clear_value(_color_clear_value);
}
////////////////////////////////////////////////////////////////////
@ -407,71 +412,36 @@ DXGraphicsStateGuardian::
// created.
////////////////////////////////////////////////////////////////////
void DXGraphicsStateGuardian::
reset() {
free_pointers();
reset(void) {
GraphicsStateGuardian::reset();
_buffer_mask = 0;
dxgsg_cat.error() << "DXGSG reset() not implemented properly yet!\n";
// delete all the objs too, right?
//dx_init();
}
// All implementations have the following buffers.
_buffer_mask = (RenderBuffer::T_color |
RenderBuffer::T_depth |
RenderBuffer::T_back
// RenderBuffer::T_stencil |
// RenderBuffer::T_accum
);
// recreate dx objects without modifying gsg state, other than clearing state cache
void DXGraphicsStateGuardian::
free_dxgsg_objects(void) {
ULONG refcnt;
_current_projection_mat = LMatrix4f::ident_mat();
_projection_mat_stack_count = 0;
free_pointers();
_issued_color_enabled = false;
_enable_all_color = true;
// this is incorrect for general mono displays, need both right and left flags set.
// stereo has not been handled yet for dx
// _buffer_mask &= ~RenderBuffer::T_right;
// Set up our clear values to invalid values, so the glClear* calls
// will be made initially.
_clear_color_red = -1.0f;
_clear_color_green = -1.0f;
_clear_color_blue = -1.0f;
_clear_color_alpha = -1.0f;
_clear_depth = -1.0f;
_clear_stencil = -1;
_clear_accum_red = -1.0f;
_clear_accum_green = -1.0f;
_clear_accum_blue = -1.0f;
_clear_accum_alpha = -1.0f;
_line_width = 1.0f;
_point_size = 1.0f;
_depth_mask = false;
_fog_mode = D3DFOG_EXP;
_alpha_func = D3DCMP_ALWAYS;
_alpha_func_ref = 0;
// _polygon_mode = GL_FILL;
// _pack_alignment = 4;
// _unpack_alignment = 4;
// Set up all the enabled/disabled flags to GL's known initial
// values: everything off.
_multisample_enabled = false;
_line_smooth_enabled = false;
_point_smooth_enabled = false;
_color_material_enabled = false;
// _scissor_enabled = false;
_lighting_enabled = false;
_normals_enabled = false;
_texturing_enabled = false;
_multisample_alpha_one_enabled = false;
_multisample_alpha_mask_enabled = false;
_blend_enabled = false;
_depth_test_enabled = false;
_fog_enabled = false;
_alpha_test_enabled = false;
_decal_level = 0;
// dont want a full reset of gsg, just a state clear
GraphicsStateGuardian::clear_cached_state(); // want gsg to pass all state settings through
_dx_ready = false;
if (_d3dDevice!=NULL) {
_d3dDevice->SetTexture(0,NULL); // should release this stuff internally anyway
RELEASE(_d3dDevice,dxgsg,"d3dDevice",RELEASE_DOWN_TO_ZERO);
}
DeleteAllVideoSurfaces();
// Release the DDraw and D3D objects used by the app
RELEASE(_zbuf,dxgsg,"zbuffer",false);
RELEASE(_back,dxgsg,"backbuffer",false);
RELEASE(_pri,dxgsg,"primary surface",false);
}
HRESULT CALLBACK EnumTexFmtsCallback( LPDDPIXELFORMAT pddpf, VOID* param ) {
@ -490,7 +460,7 @@ HRESULT CALLBACK EnumTexFmtsCallback( LPDDPIXELFORMAT pddpf, VOID* param ) {
// set up.
////////////////////////////////////////////////////////////////////
void DXGraphicsStateGuardian::
init_dx( LPDIRECTDRAW7 context,
dx_init( LPDIRECTDRAW7 context,
LPDIRECTDRAWSURFACE7 pri,
LPDIRECTDRAWSURFACE7 back,
LPDIRECTDRAWSURFACE7 zbuf,
@ -505,6 +475,69 @@ init_dx( LPDIRECTDRAW7 context,
_d3dDevice = pDevice;
_view_rect = viewrect;
_depth_write_enabled = true;
_d3dDevice->SetRenderState(D3DRENDERSTATE_ZWRITEENABLE, _depth_write_enabled);
ZeroMemory(&_lmodel_ambient,sizeof(Colorf));
_d3dDevice->SetRenderState( D3DRENDERSTATE_AMBIENT, 0x0);
_light_enabled = (bool *)NULL;
_cur_light_enabled = (bool *)NULL;
_clip_plane_enabled = (bool *)NULL;
_cur_clip_plane_enabled = (bool *)NULL;
_d3dDevice->SetRenderState(D3DRENDERSTATE_CLIPPLANEENABLE , 0x0);
_CurShadeMode = D3DSHADE_FLAT;
_d3dDevice->SetRenderState(D3DRENDERSTATE_SHADEMODE, _CurShadeMode);
// need to free these properly
_cNumTexPixFmts = 0;
_pTexPixFmts = NULL;
_pCurTexContext = NULL;
//Color and alpha transform variables
_color_transform_enabled = false;
_alpha_transform_enabled = false;
_current_color_mat = LMatrix4f::ident_mat();
_current_alpha_offset = 0;
_current_alpha_scale = 1;
// none of these are implemented
//_multisample_enabled = false;
//_point_smooth_enabled = false;
_line_smooth_enabled = false;
_d3dDevice->SetRenderState(D3DRENDERSTATE_EDGEANTIALIAS, false);
_color_material_enabled = false;
_normals_enabled = false;
_depth_test_enabled = D3DZB_FALSE;
_d3dDevice->SetRenderState(D3DRENDERSTATE_ZENABLE, D3DZB_FALSE);
_blend_enabled = false;
_d3dDevice->SetRenderState(D3DRENDERSTATE_ALPHABLENDENABLE, (DWORD)_blend_enabled);
_d3dDevice->GetRenderState(D3DRENDERSTATE_SRCBLEND, (DWORD*)&_blend_source_func);
_d3dDevice->GetRenderState(D3DRENDERSTATE_DESTBLEND, (DWORD*)&_blend_dest_func);
_fog_enabled = false;
_d3dDevice->SetRenderState(D3DRENDERSTATE_FOGENABLE, _fog_enabled);
_decal_level = 0;
_current_projection_mat = LMatrix4f::ident_mat();
_projection_mat_stack_count = 0;
_issued_color_enabled = false;
_enable_all_color = true;
// GL stuff that hasnt been translated to DX
// _scissor_enabled = false;
// _multisample_alpha_one_enabled = false;
// _multisample_alpha_mask_enabled = false;
// _line_width = 1.0f;
// _point_size = 1.0f;
assert(_back!=NULL); // dxgsg is always double-buffered right now
#ifdef COUNT_DRAWPRIMS
@ -521,6 +554,8 @@ init_dx( LPDIRECTDRAW7 context,
HRESULT hr;
_pTexPixFmts = new DDPIXELFORMAT[MAX_DX_TEXPIXFMTS];
_cNumTexPixFmts = 0;
assert(_pTexPixFmts!=NULL);
if (pDevice->EnumTextureFormats(EnumTexFmtsCallback, this) != S_OK) {
@ -542,7 +577,6 @@ init_dx( LPDIRECTDRAW7 context,
if ((dx_decal_type==GDT_offset) && !(_D3DDevDesc.dpcTriCaps.dwRasterCaps & D3DPRASTERCAPS_ZBIAS)) {
#ifdef _DEBUG
// dx7 doesnt support PLANEMASK renderstate
#if(DIRECT3D_VERSION < 0x700)
dxgsg_cat.debug() << "dx-decal-type 'offset' not supported by hardware, switching to decal masking\n";
@ -571,13 +605,13 @@ init_dx( LPDIRECTDRAW7 context,
if ((dx_decal_type==GDT_mask) && !(_D3DDevDesc.dpcTriCaps.dwMiscCaps & D3DPMISCCAPS_MASKPLANES)) {
#ifdef _DEBUG
dxgsg_cat.error() << "No hardware support for colorwrite disabling, switching to dx-decal-type 'mask' to 'blend'\n";
dxgsg_cat.debug() << "No hardware support for colorwrite disabling, switching to dx-decal-type 'mask' to 'blend'\n";
#endif
dx_decal_type = GDT_blend;
}
if (((dx_decal_type==GDT_blend)||(dx_decal_type==GDT_mask)) && !(_D3DDevDesc.dpcTriCaps.dwMiscCaps & D3DPMISCCAPS_MASKZ)) {
dxgsg_cat.error() << "dx-decal-type mask impossible to implement, no hardware support for Z-masking, decals will not appear correctly\n";
dxgsg_cat.error() << "dx-decal-type mask impossible to implement, no hardware support for Z-masking, decals will not appear correctly!\n";
}
//#define REQUIRED_BLENDCAPS (D3DPBLENDCAPS_ZERO|D3DPBLENDCAPS_ONE|D3DPBLENDCAPS_SRCCOLOR|D3DPBLENDCAPS_INVSRCCOLOR| \
@ -637,25 +671,24 @@ init_dx( LPDIRECTDRAW7 context,
}
}
SetRect(&clip_rect, 0,0,0,0); // no clip rect set
SetRect(&clip_rect, 0,0,0,0); // no clip rect set
// Lighting, let's turn it off by default
_lighting_enabled = true;
enable_lighting(false);
_lighting_enabled = false;
_d3dDevice->SetRenderState(D3DRENDERSTATE_LIGHTING, _lighting_enabled);
// turn on dithering if the rendertarget is < 8bits/color channel
DX_DECLARE_CLEAN(DDSURFACEDESC2, ddsd_back);
_back->GetSurfaceDesc(&ddsd_back);
_dither_enabled = ((ddsd_back.ddpfPixelFormat.dwRGBBitCount < 24) &&
(_D3DDevDesc.dpcTriCaps.dwRasterCaps & D3DPRASTERCAPS_DITHER));
_d3dDevice->SetRenderState(D3DRENDERSTATE_DITHERENABLE, _dither_enabled);
_d3dDevice->SetRenderState(D3DRENDERSTATE_DITHERENABLE, _dither_enabled);
_d3dDevice->SetRenderState(D3DRENDERSTATE_CLIPPING,true);
_d3dDevice->SetRenderState(D3DRENDERSTATE_CLIPPING,true);
// Stencil test is off by default
_stencil_test_enabled = false;
// _stencil_func = D3DCMP_NOTEQUAL;
// _stencil_op = D3DSTENCILOP_REPLACE;
_d3dDevice->SetRenderState(D3DRENDERSTATE_STENCILENABLE, _stencil_test_enabled);
// Antialiasing.
enable_line_smooth(false);
@ -700,24 +733,12 @@ init_dx( LPDIRECTDRAW7 context,
// initial clip rect
SetRect(&clip_rect, 0,0,0,0); // no clip rect set
// Make sure the GL state matches all of our initial attribute
// states.
PT(DepthTestTransition) dta = new DepthTestTransition;
PT(DepthWriteTransition) dwa = new DepthWriteTransition;
PT(CullFaceTransition) cfa = new CullFaceTransition;
PT(LightTransition) la = new LightTransition;
PT(TextureTransition) ta = new TextureTransition;
dta->issue(this);
dwa->issue(this);
cfa->issue(this);
la->issue(this);
// must do SetTSS here because redundant states are filtered out by our code based on current values above, so
// initial conditions must be correct
_CurTexBlendMode = TextureApplyProperty::M_modulate;
SetTextureBlendMode(_CurTexBlendMode,FALSE);
_texturing_enabled = false;
_d3dDevice->SetTextureStageState(0,D3DTSS_COLOROP,D3DTOP_DISABLE); // disables texturing
// Init more Texture State
@ -735,8 +756,6 @@ init_dx( LPDIRECTDRAW7 context,
_d3dDevice->SetTextureStageState(0, D3DTSS_ADDRESSU,get_texture_wrap_mode(_CurTexWrapModeU));
_d3dDevice->SetTextureStageState(0, D3DTSS_ADDRESSV,get_texture_wrap_mode(_CurTexWrapModeV));
ta->issue(this); // no curtextcontext, this does nothing. dx should already be properly inited above anyway
#ifdef _DEBUG
if ((_D3DDevDesc.dpcTriCaps.dwRasterCaps & D3DPRASTERCAPS_MIPMAPLODBIAS) &&
(dx_global_miplevel_bias!=0.0f)) {
@ -744,8 +763,6 @@ init_dx( LPDIRECTDRAW7 context,
}
#endif
_d3dDevice->SetRenderState(D3DRENDERSTATE_SHADEMODE, _CurShadeMode);
if(dx_full_screen_antialiasing) {
if(_D3DDevDesc.dpcTriCaps.dwRasterCaps & D3DPRASTERCAPS_ANTIALIASSORTINDEPENDENT) {
_d3dDevice->SetRenderState(D3DRENDERSTATE_ANTIALIAS,D3DANTIALIAS_SORTINDEPENDENT);
@ -770,7 +787,16 @@ init_dx( LPDIRECTDRAW7 context,
}
#endif
// need to release this better, so init_dx can be called multiple times
_d3dDevice->SetRenderState(D3DRENDERSTATE_CULLMODE, dx_force_backface_culling);
_alpha_func = D3DCMP_ALWAYS;
_alpha_func_ref = 0;
_d3dDevice->SetRenderState(D3DRENDERSTATE_ALPHAFUNC, _alpha_func);
_d3dDevice->SetRenderState(D3DRENDERSTATE_ALPHAREF, _alpha_func_ref);
_alpha_test_enabled = false;
_d3dDevice->SetRenderState(D3DRENDERSTATE_ALPHATESTENABLE, _alpha_test_enabled);
// need to release this better, so dx_init can be called multiple times
if(dx_show_fps_meter) {
_start_time = timeGetTime();
@ -841,7 +867,10 @@ init_dx( LPDIRECTDRAW7 context,
ddsd.dwWidth = texdim_x;
ddsd.dwHeight = texdim_y;
assert(_fpsmeter_font_surf==NULL);
if(_fpsmeter_font_surf!=NULL) {
ULONG refcnt;
RELEASE(_fpsmeter_font_surf,dxgsg,"fpsmeter fontsurf",false);
}
PRINTREFCNT(_pDD,"pre-fpsmeter-font-create IDirectDraw7");
@ -863,13 +892,27 @@ init_dx( LPDIRECTDRAW7 context,
int numverts=(NUM_FPSMETER_LETTERS+1)*2*3; // +1 for square to hold suffix
_fpsmeter_verts = (DWORD *) new BYTE[_fps_vertexsize*numverts]; //bugbug remember to release this
if(_fpsmeter_verts == NULL)
_fpsmeter_verts = (DWORD *) new BYTE[_fps_vertexsize*numverts];
_fps_u_usedwidth = letterfontareaWidth/(float)texdim_x;
_fps_v_usedheight = fontareaHeight/(float)texdim_y;
SetFPSMeterPosition(_view_rect);
}
// Make sure the DX state matches all of our initial attribute states.
PT(DepthTestTransition) dta = new DepthTestTransition;
PT(DepthWriteTransition) dwa = new DepthWriteTransition;
PT(CullFaceTransition) cfa = new CullFaceTransition;
PT(LightTransition) la = new LightTransition;
PT(TextureTransition) ta = new TextureTransition;
dta->issue(this);
dwa->issue(this);
cfa->issue(this);
la->issue(this);
ta->issue(this); // no curtextcontext, this does nothing. dx should already be properly inited above anyway
}
////////////////////////////////////////////////////////////////////
@ -894,9 +937,7 @@ clear(const RenderBuffer &buffer) {
if (buffer_type & RenderBuffer::T_stencil)
flags |= D3DCLEAR_STENCIL;
D3DCOLOR clear_colr = Colorf_to_D3DCOLOR(_color_clear_value);
HRESULT hr = _d3dDevice->Clear(0, NULL, flags, clear_colr,
HRESULT hr = _d3dDevice->Clear(0, NULL, flags, _d3dcolor_clear_value,
(D3DVALUE) _depth_clear_value, (DWORD)_stencil_clear_value);
if (hr != DD_OK)
dxgsg_cat.error() << "clear_buffer failed: Clear returned " << ConvD3DErrorToString(hr) << endl;
@ -1299,7 +1340,7 @@ render_frame() {
_d3dDevice->SetRenderState(D3DRENDERSTATE_FILLMODE, saved_fill_state);
}
_d3dDevice->SetTexture(0, _pCurDeviceTexture);
_d3dDevice->SetTexture(0, ((_pCurTexContext != NULL) ? _pCurTexContext->_surface : NULL));
}
hr = _d3dDevice->EndScene();
@ -2707,9 +2748,9 @@ draw_tri(GeomTri *geom, GeomContext *gc) {
DO_PSTATS_STUFF(PStatTimer timer(_draw_primitive_pcollector));
DO_PSTATS_STUFF(_vertices_tri_pcollector.add_level(geom->get_num_vertices()));
#ifdef _DEBUG
if (_pCurTexContext!=NULL) {
// dxgsg_cat.spam() << "Cur active DX texture: " << _pCurTexContext->_tex->get_name() << "\n";
#if 0
if (_pCurTexContext!=NULL) {
dxgsg_cat.spam() << "Cur active DX texture: " << _pCurTexContext->_tex->get_name() << "\n";
}
#endif
@ -3808,7 +3849,7 @@ apply_texture(TextureContext *tc) {
// bind_texture(tc);
// specify_texture(tc->_texture);
// Note: if this code changes, make sure to change initialization SetTSS code in init_dx as well
// Note: if this code changes, make sure to change initialization SetTSS code in dx_init as well
// so DX TSS renderstate matches dxgsg state
DXTextureContext *dtc = DCAST(DXTextureContext, tc);
@ -3844,13 +3885,7 @@ apply_texture(TextureContext *tc) {
int aniso_degree=tex->get_anisotropic_degree();
Texture::FilterType ft=tex->get_magfilter();
if (aniso_degree>1) {
if (aniso_degree!=_CurTexAnisoDegree) {
_CurTexAnisoDegree = aniso_degree;
_d3dDevice->SetTextureStageState(0, D3DTSS_MAGFILTER, D3DTFG_ANISOTROPIC );
_d3dDevice->SetTextureStageState(0, D3DTSS_MAXANISOTROPY,aniso_degree);
}
} else {
if (aniso_degree<=1) {
if (_CurTexMagFilter!=ft) {
_CurTexMagFilter = ft;
@ -3861,6 +3896,12 @@ apply_texture(TextureContext *tc) {
}
#endif
}
} else {
if (aniso_degree!=_CurTexAnisoDegree) {
_CurTexAnisoDegree = aniso_degree;
_d3dDevice->SetTextureStageState(0, D3DTSS_MAGFILTER, D3DTFG_ANISOTROPIC );
_d3dDevice->SetTextureStageState(0, D3DTSS_MAXANISOTROPY,aniso_degree);
}
}
#ifdef _DEBUG
@ -3942,7 +3983,7 @@ apply_texture(TextureContext *tc) {
// bugbug: does this handle the case of untextured geometry?
// we dont see this bug cause we never mix textured/untextured
SetDeviceTexture(dtc->_surface);
_d3dDevice->SetTexture(0,dtc->_surface);
#if 0
if (dtc!=NULL) {
@ -4400,6 +4441,7 @@ apply_fog(Fog *fog) {
Fog::Mode panda_fogmode = fog->get_mode();
D3DFOGMODE d3dfogmode = get_fog_mode_type(panda_fogmode);
// should probably avoid doing redundant SetRenderStates, but whatever
_d3dDevice->SetRenderState((D3DRENDERSTATETYPE)_doFogType, d3dfogmode);
@ -5068,8 +5110,7 @@ void DXGraphicsStateGuardian::issue_light(const LightTransition *attrib ) {
}
}
/*
////////////////////////////////////////////////////////////////////
// Function: DXGraphicsStateGuardian::reset_ambient
// Access: Public, Virtual
@ -5079,7 +5120,7 @@ void DXGraphicsStateGuardian::
reset_ambient() {
_lmodel_ambient += 2.0f;
}
*/
////////////////////////////////////////////////////////////////////
// Function: DXGraphicsStateGuardian::issue_color_blend //
@ -5300,26 +5341,19 @@ issue_stencil(const StencilTransition *attrib) {
StencilProperty::Mode mode = attrib->get_mode();
#if 1
if (mode != StencilProperty::M_none) {
dxgsg_cat.error() << "stencil buffering unimplemented for DX GSG renderer!!!\n";
// to implement stenciling, need to change wdxGraphicsWindow to create a stencil
// z-buffer or maybe do a SetRenderTarget on a new zbuffer
}
#else
if (mode == StencilProperty::M_none) {
enable_stencil_test(false);
} else {
enable_stencil_test(true);
// TODO: need to cache all these
_d3dDevice->SetRenderState(D3DRENDERSTATE_STENCILFUNC, get_stencil_func_type(mode));
_d3dDevice->SetRenderState(D3DRENDERSTATE_STENCILPASS, get_stencil_action_type(attrib->get_action()));
_d3dDevice->SetRenderState(D3DRENDERSTATE_STENCILFAIL, get_stencil_action_type(attrib->get_action()));
_d3dDevice->SetRenderState(D3DRENDERSTATE_STENCILZFAIL, get_stencil_action_type(attrib->get_action()));
_d3dDevice->SetRenderState(D3DRENDERSTATE_STENCILPASS, get_stencil_action_type(attrib->get_pass_action()));
_d3dDevice->SetRenderState(D3DRENDERSTATE_STENCILFAIL, get_stencil_action_type(attrib->get_fail_action()));
_d3dDevice->SetRenderState(D3DRENDERSTATE_STENCILZFAIL, get_stencil_action_type(attrib->get_zfail_action()));
_d3dDevice->SetRenderState(D3DRENDERSTATE_STENCILREF, attrib->get_reference_value());
_d3dDevice->SetRenderState(D3DRENDERSTATE_STENCILMASK, attrib->get_func_mask());
_d3dDevice->SetRenderState(D3DRENDERSTATE_STENCILWRITEMASK, attrib->get_write_mask());
}
#endif
}
////////////////////////////////////////////////////////////////////
@ -5818,9 +5852,6 @@ get_depth_func_type(DepthTestProperty::Mode m) const {
return D3DCMP_LESS;
}
#if 0
// ifdef out until stencil zbuf creation works in wdxGraphicsWindow.c
////////////////////////////////////////////////////////////////////
// Function: DXGraphicsStateGuardian::get_stencil_func_type
// Access: Protected
@ -5838,8 +5869,7 @@ get_stencil_func_type(StencilProperty::Mode m) const {
case StencilProperty::M_greater_equal: return D3DCMP_GREATEREQUAL;
case StencilProperty::M_always: return D3DCMP_ALWAYS;
}
dxgsg_cat.error()
<< "Invalid StencilProperty::Mode value" << endl;
dxgsg_cat.error() << "Invalid StencilProperty::Mode value" << endl;
return D3DCMP_LESS;
}
@ -5859,13 +5889,10 @@ get_stencil_action_type(StencilProperty::Action a) const {
case StencilProperty::A_decrement: return D3DSTENCILOP_DECR;
case StencilProperty::A_invert: return D3DSTENCILOP_INVERT;
}
dxgsg_cat.error()
<< "Invalid StencilProperty::Action value" << endl;
dxgsg_cat.error() << "Invalid StencilProperty::Action value" << endl;
return D3DSTENCILOP_KEEP;
}
#endif
////////////////////////////////////////////////////////////////////
// Function: DXGraphicsStateGuardian::get_fog_mode_type
// Access: Protected
@ -6228,6 +6255,55 @@ bool refill_tex_callback(TextureContext *tc,void *void_dxgsg_ptr) {
return hr==S_OK;
}
bool delete_tex_callback(TextureContext *tc,void *void_dxgsg_ptr) {
DXTextureContext *dtc = DCAST(DXTextureContext, tc);
// release DDSurf (but not the texture context)
dtc->DeleteTexture();
return true;
}
bool recreate_tex_callback(TextureContext *tc,void *void_dxgsg_ptr) {
DXTextureContext *dtc = DCAST(DXTextureContext, tc);
DXGraphicsStateGuardian *dxgsg = (DXGraphicsStateGuardian *)void_dxgsg_ptr;
// Re-fill the contents of textures and vertex buffers
// which just got restored now.
LPDIRECTDRAWSURFACE7 ddtex = dtc->CreateTexture(dxgsg->_d3dDevice,
dxgsg->_cNumTexPixFmts,dxgsg->_pTexPixFmts);
return ddtex!=NULL;
}
// release all textures and vertex/index buffers
HRESULT DXGraphicsStateGuardian::DeleteAllVideoSurfaces(void) {
// BUGBUG: need to handle vertexbuffer handling here
// cant access template in libpanda.dll directly due to vc++ limitations, use traverser to get around it
traverse_prepared_textures(delete_tex_callback,this);
ULONG refcnt;
if(dx_show_fps_meter)
RELEASE(_fpsmeter_font_surf,dxgsg,"fpsmeter fontsurf",false);
if(dxgsg_cat.is_debug())
dxgsg_cat.debug() << "release of all textures complete\n";
return S_OK;
}
// recreate all textures and vertex/index buffers
HRESULT DXGraphicsStateGuardian::RecreateAllVideoSurfaces(void) {
// BUGBUG: need to handle vertexbuffer handling here
// cant access template in libpanda.dll directly due to vc++ limitations, use traverser to get around it
traverse_prepared_textures(recreate_tex_callback,this);
if(dxgsg_cat.is_debug())
dxgsg_cat.debug() << "recreation of all textures complete\n";
return S_OK;
}
HRESULT DXGraphicsStateGuardian::RestoreAllVideoSurfaces(void) {
// BUGBUG: this should also restore vertex buffer contents when they are implemented
// You will need to destroy and recreate

72
panda/src/dxgsg/dxGraphicsStateGuardian.h
View File

@ -122,6 +122,9 @@ extern void dbgPrintVidMem(LPDIRECTDRAW7 pDD, LPDDSCAPS2 lpddsCaps,const char *p
// outside of this object.
////////////////////////////////////////////////////////////////////
class EXPCL_PANDADX DXGraphicsStateGuardian : public GraphicsStateGuardian {
friend class wdxGraphicsWindow;
friend class DXTextureContext;
public:
DXGraphicsStateGuardian(GraphicsWindow *win);
~DXGraphicsStateGuardian();
@ -220,11 +223,17 @@ public:
virtual void end_decal(GeomNode *base_geom);
INLINE float compute_distance_to(const LPoint3f &point) const;
virtual void set_color_clear_value(const Colorf& value);
void reset_ambient();
public:
// recreate_tex_callback needs these to be public
LPDIRECT3DDEVICE7 _d3dDevice;
LPDDPIXELFORMAT _pTexPixFmts;
int _cNumTexPixFmts;
protected:
void free_pointers();
void free_pointers(); // free local internal buffers
void free_dxgsg_objects(void); // free the DirectX objects we create
virtual PT(SavedFrameBuffer) save_frame_buffer(const RenderBuffer &buffer,
CPT(DisplayRegion) dr);
virtual void restore_frame_buffer(SavedFrameBuffer *frame_buffer);
@ -245,15 +254,12 @@ protected:
LPDIRECTDRAWSURFACE7 _back;
LPDIRECTDRAWSURFACE7 _zbuf;
LPDIRECT3D7 _d3d;
LPDIRECT3DDEVICE7 _d3dDevice;
LPDIRECTDRAWSURFACE7 _pri;
LPDIRECTDRAW7 _pDD;
RECT _view_rect;
RECT clip_rect;
HDC _front_hdc;
int _cNumTexPixFmts;
LPDDPIXELFORMAT _pTexPixFmts;
DXTextureContext *_pCurTexContext;
bool _bTransformIssued; // decaling needs to tell when a transform has been issued
@ -268,14 +274,16 @@ protected:
D3DVECTOR *pCenter, float fRadius,
DWORD wNumRings, DWORD wNumSections, float sx, float sy, float sz,
DWORD *pNumVertices,DWORD *pNumIndices,DWORD fvfFlags,DWORD dwVertSize);
HRESULT DXGraphicsStateGuardian::RestoreAllVideoSurfaces(void);
INLINE void set_pack_alignment(int alignment);
INLINE void set_unpack_alignment(int alignment);
HRESULT RestoreAllVideoSurfaces(void);
HRESULT RecreateAllVideoSurfaces(void);
HRESULT DeleteAllVideoSurfaces(void);
/*
INLINE void enable_multisample_alpha_one(bool val);
INLINE void enable_multisample_alpha_mask(bool val);
INLINE void enable_multisample(bool val);
*/
INLINE void enable_color_material(bool val);
INLINE void enable_clip_plane(int clip_plane, bool val);
INLINE void enable_fog(bool val);
@ -285,15 +293,9 @@ protected:
INLINE D3DCMPFUNC get_depth_func_type(DepthTestProperty::Mode m) const;
INLINE D3DFOGMODE get_fog_mode_type(Fog::Mode m) const;
#if 0
INLINE D3DCMPFUNC get_stencil_func_type(StencilProperty::Mode m) const;
INLINE D3DSTENCILOP get_stencil_action_type(StencilProperty::Action a) const;
#endif
INLINE D3DCMPFUNC get_stencil_func_type(StencilProperty::Mode m) const;
INLINE D3DSTENCILOP get_stencil_action_type(StencilProperty::Action a) const;
/* INLINE void enable_multisample_alpha_one(bool val);
INLINE void enable_multisample_alpha_mask(bool val);
INLINE void enable_multisample(bool val, LPDIRECT3DDEVICE7 d3dDevice);
*/
INLINE void enable_alpha_test(bool val);
INLINE void enable_line_smooth(bool val);
INLINE void enable_blend(bool val);
@ -328,6 +330,7 @@ protected:
bool _enable_all_color;
Colorf _issued_color; // WBD ADDED
D3DCOLOR _issued_color_D3DCOLOR; // WBD ADDED
D3DCOLOR _d3dcolor_clear_value;
D3DSHADEMODE _CurShadeMode;
@ -340,27 +343,12 @@ protected:
Geom::TexCoordIterator ti;
Geom::ColorIterator ci;
float _clear_color_red, _clear_color_green, _clear_color_blue,_clear_color_alpha;
double _clear_depth;
int _clear_stencil;
float _clear_accum_red, _clear_accum_green, _clear_accum_blue,_clear_accum_alpha;
int _scissor_x;
int _scissor_y;
int _scissor_width;
int _scissor_height;
int _viewport_x;
int _viewport_y;
int _viewport_width;
int _viewport_height;
Colorf _lmodel_ambient;
float _material_ambient;
float _material_diffuse;
float _material_specular;
float _material_shininess;
float _material_emission;
float _line_width;
float _point_size;
bool _depth_mask;
typedef enum {None,
PerVertexFog=D3DRENDERSTATE_FOGVERTEXMODE,
@ -368,19 +356,20 @@ protected:
} DxgsgFogType;
DxgsgFogType _doFogType;
bool _fog_enabled;
int _fog_mode;
/*
TODO: cache fog state
float _fog_start;
float _fog_end;
float _fog_density;
float _fog_color;
float _alpha_func_ref;
D3DCMPFUNC _alpha_func;
*/
float _alpha_func_ref;
D3DCMPFUNC _alpha_func;
D3DBLEND _blend_source_func;
D3DBLEND _blend_dest_func;
bool _multisample_enabled;
bool _line_smooth_enabled;
bool _point_smooth_enabled;
bool* _light_enabled; // bool[_max_lights]
bool _color_material_enabled;
bool _lighting_enabled;
@ -389,16 +378,11 @@ protected:
bool _dither_enabled;
bool _stencil_test_enabled;
bool* _clip_plane_enabled; // bool[_max_clip_planes]
bool _multisample_alpha_one_enabled;
bool _multisample_alpha_mask_enabled;
bool _blend_enabled;
bool _depth_test_enabled;
bool _depth_write_enabled;
DWORD _old_colormaskval;
bool _alpha_test_enabled;
int _decal_level;
LPDIRECTDRAWSURFACE7 _pCurDeviceTexture;
INLINE void SetDeviceTexture(LPDIRECTDRAWSURFACE7 pTexture);
RenderModeProperty::Mode _current_fill_mode; //poinr/wireframe/solid
@ -433,8 +417,6 @@ protected:
float _current_alpha_offset;
float _current_alpha_scale;
int _pass_number;
// vars for frames/sec meter
DWORD _start_time;
DWORD _start_frame_count;
@ -476,7 +458,7 @@ public:
void show_frame();
void show_full_screen_frame();
void show_windowed_frame();
void init_dx( LPDIRECTDRAW7 context,
void dx_init( LPDIRECTDRAW7 context,
LPDIRECTDRAWSURFACE7 pri,
LPDIRECTDRAWSURFACE7 back,
LPDIRECTDRAWSURFACE7 zbuf,

10
panda/src/dxgsg/dxTextureContext.h
View File

@ -45,6 +45,9 @@
// Description :
////////////////////////////////////////////////////////////////////
class EXPCL_PANDADX DXTextureContext : public TextureContext {
friend class DXGraphicsStateGuardian;
friend class wdxGraphicsWindow;
public:
DXTextureContext(Texture *tex);
~DXTextureContext();
@ -54,10 +57,11 @@ public:
LPDIRECTDRAWSURFACE7 CreateTexture(LPDIRECT3DDEVICE7 pd3dDevice, int cNumTexPixFmts, LPDDPIXELFORMAT pTexPixFmts);
void DeleteTexture();
bool _bHasMipMaps;
DWORD _PixBufConversionType; // enum ConversionType
// must be public since called from global callback fns
void DeleteTexture(void);
HRESULT FillDDSurfTexturePixels(void);
protected:
@ -79,8 +83,6 @@ public:
private:
static TypeHandle _type_handle;
friend class DXGraphicsStateGuardian;
};

2
panda/src/wdxdisplay/config_wdxdisplay.cxx
View File

@ -60,6 +60,8 @@ init_libwdxdisplay() {
GraphicsWindow::get_factory().register_factory(
wdxGraphicsWindow::get_class_type(),
wdxGraphicsWindow::make_wdxGraphicsWindow);
set_global_parameters();
}
// cant use global var cleanly because global var static init executed after init_libwdxdisplay(), incorrectly reiniting var

11
panda/src/wdxdisplay/wdxGraphicsPipe.cxx
View File

@ -62,9 +62,11 @@ TypeHandle wdxGraphicsPipe::get_class_type(void) {
return _type_handle;
}
const char *pipe_type_name="wdxGraphicsPipe";
void wdxGraphicsPipe::init_type(void) {
InteractiveGraphicsPipe::init_type();
register_type(_type_handle, "wdxGraphicsPipe",
register_type(_type_handle, pipe_type_name,
InteractiveGraphicsPipe::get_class_type());
}
@ -74,18 +76,17 @@ TypeHandle wdxGraphicsPipe::get_type(void) const {
wdxGraphicsPipe::wdxGraphicsPipe(void) {
wdxdisplay_cat.error()
<< "wdxGraphicsPipes should not be created with the default constructor"
<< endl;
<< pipe_type_name <<"s should not be created with the default constructor" << endl;
}
wdxGraphicsPipe::wdxGraphicsPipe(const wdxGraphicsPipe&) {
wdxdisplay_cat.error()
<< "wdxGraphicsPipes should not be copied" << endl;
<< pipe_type_name << "s should not be copied" << endl;
}
wdxGraphicsPipe& wdxGraphicsPipe::operator=(const wdxGraphicsPipe&) {
wdxdisplay_cat.error()
<< "wdxGraphicsPipes should not be assigned" << endl;
<< pipe_type_name << "s should not be assigned" << endl;
return *this;
}

875
panda/src/wdxdisplay/wdxGraphicsWindow.cxx
View File

File diff suppressed because it is too large Load Diff

17
panda/src/wdxdisplay/wdxGraphicsWindow.h
View File

@ -44,8 +44,8 @@ const int WDXWIN_EVENT = 8;
// Description :
////////////////////////////////////////////////////////////////////
class EXPCL_PANDADX wdxGraphicsWindow : public GraphicsWindow {
friend class DXGraphicsStateGuardian;
friend class DXGraphicsStateGuardian;
friend class DXTextureContext;
public:
wdxGraphicsWindow(GraphicsPipe* pipe);
@ -59,6 +59,9 @@ public:
virtual TypeHandle get_gsg_type() const;
static GraphicsWindow* make_wdxGraphicsWindow(const FactoryParams &params);
void CreateScreenBuffersAndDevice(DWORD dwRenderWidth, DWORD dwRenderHeight,
LPDIRECTDRAW7 pDD,LPDIRECT3D7 pD3DI,
D3DDEVICEDESC7 *pD3DDevDesc);
LONG window_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam);
void process_events(void);
@ -78,10 +81,11 @@ public:
void show_frame();
DXGraphicsStateGuardian *_dxgsg;
// virtual void resize(unsigned int xsize,unsigned int ysize);
// virtual unsigned int verify_window_sizes(unsigned int numsizes,unsigned int *dimen);
virtual void resize(unsigned int xsize,unsigned int ysize);
virtual unsigned int verify_window_sizes(unsigned int numsizes,unsigned int *dimen);
protected:
void CreateScreenBuffersAndDevice(LPDIRECTDRAW7 pDD,LPDIRECT3D7 pD3DI);
ButtonHandle lookup_key(WPARAM wparam) const;
virtual void config( void );
void setup_colormap(void);
@ -90,6 +94,7 @@ protected:
void enable_mouse_motion(bool val);
void enable_mouse_passive_motion(bool val);
void enable_mouse_entry(bool val);
DDDEVICEIDENTIFIER2 _DXDeviceID;
public:
HWND _mwindow;
@ -131,4 +136,8 @@ private:
static TypeHandle _type_handle;
};
extern void set_global_parameters(void);
extern void restore_global_parameters(void);
#endif