From 13825d57667d4ef8f274a80a9bd7669eac07f4f0 Mon Sep 17 00:00:00 2001 From: cxgeorge <> Date: Sun, 24 Jun 2001 05:25:20 +0000 Subject: [PATCH] fix global color --- panda/src/dxgsg/config_dxgsg.cxx | 12 +- panda/src/dxgsg/config_dxgsg.h | 13 +- panda/src/dxgsg/dxGraphicsStateGuardian.cxx | 257 +++++++++----------- panda/src/dxgsg/dxGraphicsStateGuardian.h | 7 +- panda/src/dxgsg/dxTextureContext.cxx | 19 +- 5 files changed, 145 insertions(+), 163 deletions(-) diff --git a/panda/src/dxgsg/config_dxgsg.cxx b/panda/src/dxgsg/config_dxgsg.cxx index 6917badb5c..0a2bd63607 100644 --- a/panda/src/dxgsg/config_dxgsg.cxx +++ b/panda/src/dxgsg/config_dxgsg.cxx @@ -45,24 +45,28 @@ bool dx_full_screen_antialiasing = config_dxgsg.GetBool("dx-antialias", false); // for state-sorting, z-sorting, and binning. bool dx_cull_traversal = config_dxgsg.GetBool("dx-cull-traversal", true); -bool dx_ignore_mipmaps = config_dxgsg.GetBool("dx-ignore-mipmaps", false); -float dx_global_miplevel_bias = config_dxgsg.GetFloat("dx-global-miplevel-bias", 0.0); - // if true, if card only supports per-vertex fog, it will be treated as no-HW fog capability bool dx_no_vertex_fog = config_dxgsg.GetBool("dx-no-vertex-fog", false); +// is this implemented yet? bool dx_force_16bpp_screenbuffers = config_dxgsg.GetBool("dx-force-16bpp-screenbuffers", false); + bool dx_show_fps_meter = config_dxgsg.GetBool("show-fps-meter", false); float dx_fps_meter_update_interval = max(0.5,config_dxgsg.GetFloat("fps-meter-update-interval", 1.7)); +#ifndef NDEBUG // debugging flag // values are same as D3DCULL enumtype, 0 - no force, 1 - force none, 2 - force CW, 3 - force CCW int dx_force_backface_culling = config_dxgsg.GetInt("dx-force-backface-culling", 0); +#endif + +bool dx_mipmap_everything = config_dxgsg.GetBool("dx-mipmap-everything", false); +bool dx_ignore_mipmaps = config_dxgsg.GetBool("dx-ignore-mipmaps", false); #ifdef _DEBUG +float dx_global_miplevel_bias = config_dxgsg.GetFloat("dx-global-miplevel-bias", 0.0); bool dx_debug_view_mipmaps = config_dxgsg.GetBool("dx-debug-view-mipmaps", false); bool dx_force_16bpptextures = config_dxgsg.GetBool("dx-force-16bpptextures", false); -bool dx_mipmap_everything = config_dxgsg.GetBool("dx-mipmap-everything", false); bool dx_force_anisotropic_filtering = config_dxgsg.GetBool("dx-force-anisotropic-filtering", false); #endif diff --git a/panda/src/dxgsg/config_dxgsg.h b/panda/src/dxgsg/config_dxgsg.h index 479024dedf..d2f4fc544e 100644 --- a/panda/src/dxgsg/config_dxgsg.h +++ b/panda/src/dxgsg/config_dxgsg.h @@ -24,24 +24,27 @@ NotifyCategoryDecl(dxgsg, EXPCL_PANDADX, EXPTP_PANDADX); -extern bool dx_show_transforms; extern bool dx_full_screen; extern bool dx_sync_video; extern bool dx_cull_traversal; -extern bool dx_ignore_mipmaps; -extern bool dx_force_16bpp_screenbuffers; extern bool dx_show_fps_meter; extern bool dx_no_vertex_fog; extern bool dx_full_screen_antialiasing; extern float dx_fps_meter_update_interval; -// this is really a debug flag, but I need at Opt4 for perf-measurement +// debug flags +extern bool dx_ignore_mipmaps; +extern bool dx_mipmap_everything; +extern bool dx_force_16bpp_screenbuffers; +extern bool dx_show_transforms; + +#ifndef NDEBUG extern int dx_force_backface_culling; +#endif #ifdef _DEBUG extern float dx_global_miplevel_bias; extern bool dx_debug_view_mipmaps; -extern bool dx_mipmap_everything; extern bool dx_force_16bpptextures; extern bool dx_force_anisotropic_filtering; #endif diff --git a/panda/src/dxgsg/dxGraphicsStateGuardian.cxx b/panda/src/dxgsg/dxGraphicsStateGuardian.cxx index 3feba87d42..b060294dbe 100644 --- a/panda/src/dxgsg/dxGraphicsStateGuardian.cxx +++ b/panda/src/dxgsg/dxGraphicsStateGuardian.cxx @@ -30,6 +30,11 @@ //#define PRINT_TEXSTATS +// test non-optimized general geom pipe for all models +// apparently DPStrided faults for some color G_OVERALL cases, so comment out for now +// not clear that it is actually faster in practice, it may even be slightly slower +#define DONT_USE_DRAWPRIMSTRIDED + //const int VERT_BUFFER_SIZE = (8*1024L); // For sparkle particles, we can have 4 vertices per sparkle, and a // particle pool size of 1024 particles @@ -51,11 +56,6 @@ TypeHandle DXGraphicsStateGuardian::_type_handle; // and so I dont have to write code that reallocs light arrays #define DXGSG_MAX_LIGHTS 8 -// test non-optimized general geom pipe for all models -// apparently DPStrided faults for some color G_OVERALL cases, so comment out for now -// not clear that it is actually faster in practice, it may even be slightly slower -#define DONT_USE_DRAWPRIMSTRIDED - static D3DMATRIX matIdentity; #define Colorf_to_D3DCOLOR(out_color) (D3DRGBA((out_color)[0], (out_color)[1], (out_color)[2], (out_color)[3])) @@ -162,6 +162,7 @@ reset() { _projection_mat_stack_count = 0; _issued_color_enabled = false; + _enable_all_color = true; _buffer_mask &= ~RenderBuffer::T_right; // test for these later @@ -1118,49 +1119,76 @@ draw_prim_setup(const Geom *geom) { //////// - vi = geom->make_vertex_iterator(); - p_flags = D3DFVF_XYZ; - size_t vertex_size = sizeof(D3DVALUE) * 3; + vi = geom->make_vertex_iterator(); + p_flags = D3DFVF_XYZ; + size_t vertex_size = sizeof(D3DVALUE) * 3; - if ((geom->get_binding(G_COLOR) != G_OFF) || _issued_color_enabled) { + GeomBindType ColorBinding=geom->get_binding(G_COLOR); + bool bDoColor=(ColorBinding != G_OFF); + + if (_enable_all_color && (bDoColor || _issued_color_enabled)) { ci = geom->make_color_iterator(); p_flags |= D3DFVF_DIFFUSE; vertex_size += sizeof(D3DCOLOR); - if (geom->get_binding(G_COLOR) == G_OVERALL) { - GET_NEXT_COLOR(); - } - if (_issued_color_enabled) { - p_colr = _issued_color; // set primitive color if there is one. - perVertex &= ~PER_COLOR; - perPrim &= ~PER_COLOR; - perComp &= ~PER_COLOR; - } - } + p_colr = _issued_color_D3DCOLOR; // set primitive color if there is one. + } else if(ColorBinding == G_OVERALL){ + GET_NEXT_COLOR(); + } - if (geom->get_binding(G_NORMAL) != G_OFF) { + perVertex &= ~PER_COLOR; + perPrim &= ~PER_COLOR; + perComp &= ~PER_COLOR; + } + + if (geom->get_binding(G_NORMAL) != G_OFF) { ni = geom->make_normal_iterator(); p_flags |= D3DFVF_NORMAL; vertex_size += sizeof(D3DVALUE) * 3; if (geom->get_binding(G_NORMAL) == G_OVERALL) p_normal = geom->get_next_normal(ni); // set overall normal if there is one - } + } - if (geom->get_binding(G_TEXCOORD) != G_OFF) { + if (geom->get_binding(G_TEXCOORD) != G_OFF) { ti = geom->make_texcoord_iterator(); p_flags |= (D3DFVF_TEX1 | D3DFVF_TEXCOORDSIZE2(0)); vertex_size += sizeof(float) * 2; - } + } // If we have per-vertex colors or normals, we need smooth shading. // Otherwise we want flat shading for performance reasons. - if (perVertex & ((wants_colors() ? PER_COLOR : 0) | (wants_normals() ? PER_NORMAL : 0))) - set_shademode(D3DSHADE_GOURAUD); - else set_shademode(D3DSHADE_FLAT); - return vertex_size; + if (perVertex & (PER_COLOR | (wants_normals() ? PER_NORMAL : 0))) + set_shademode(D3DSHADE_GOURAUD); + else set_shademode(D3DSHADE_FLAT); + + return vertex_size; +} + +//////////////////////////////////////////////////////////////////// +// Function: DXGraphicsStateGuardian::wants_colors +// Access: Public, Virtual +// Description: Returns true if the GSG should issue geometry color +// commands, false otherwise. +//////////////////////////////////////////////////////////////////// +INLINE bool DXGraphicsStateGuardian:: +wants_colors() const { + // If we have scene graph color enabled, return false to indicate we + // shouldn't bother issuing geometry color commands. + + const ColorAttribute *catt; + if (!get_attribute_into(catt, _state, ColorTransition::get_class_type())) { + // No scene graph color at all. + return true; + } + + // We should issue geometry colors only if the scene graph color is off. + if (catt->is_off() || (!catt->is_real())) + return true; + + return false; } //////////////////////////////////////////////////////////////////// @@ -1390,43 +1418,6 @@ draw_line(GeomLine* geom, GeomContext *gc) { } #endif -#ifdef WBD_GL_MODE - call_glLineWidth(geom->get_width()); - - int nprims = geom->get_num_prims(); - Geom::VertexIterator vi = geom->make_vertex_iterator(); - Geom::ColorIterator ci = geom->make_color_iterator(); - - GeomIssuer issuer(geom, this, - issue_vertex_gl, - issue_normal_gl, - issue_texcoord_gl, - issue_color_gl); - - if (geom->get_binding(G_COLOR) == G_PER_VERTEX) { - call_glShadeModel(GL_SMOOTH); - } else { - call_glShadeModel(GL_FLAT); - } - - // Draw overall - issuer.issue_color(G_OVERALL, ci); - - glBegin(GL_LINES); - - for (int i = 0; i < nprims; i++) { - // Draw per primitive - issuer.issue_color(G_PER_PRIM, ci); - - for (int j = 0; j < 2; j++) { - // Draw per vertex - issuer.issue_color(G_PER_VERTEX, ci); - issuer.issue_vertex(G_PER_VERTEX, vi); - } - } - - glEnd(); -#else // the DX way int nPrims = geom->get_num_prims(); @@ -1492,8 +1483,6 @@ draw_line(GeomLine* geom, GeomContext *gc) { TestDrawPrimFailure(DrawPrim,hr,_pDD,nPrims*2,0); _pCurFvfBufPtr = NULL; - -#endif // WBD_GL_MODE } void DXGraphicsStateGuardian:: @@ -1622,14 +1611,6 @@ struct draw_sprite_vertex_less { return v0.z > v1.z; // reversed from gl due to left-handed coordsys of d3d } }; -/* -struct draw_sprite_vertex_less { - INLINE bool operator ()(const WrappedSprite& v0, - const WrappedSprite& v1) const { - return v0._v[2] > v1._v[2]; // reversed from gl - } -}; -*/ //////////////////////////////////////////////////////////////////// // Function: DXGraphicsStateGuardian::draw_sprite @@ -1690,7 +1671,7 @@ draw_sprite(GeomSprite *geom, GeomContext *gc) { float aspect_ratio; aspect_ratio = _actual_display_region->get_camera()->get_aspect(); - // null the world xform, so sprites are orthog to scrn (but not necessarily camera pntm unless they lie along z-axis) + // null the world xform, so sprites are orthog to scrn (but not necessarily camera pnt unless they lie along z-axis) _d3dDevice->SetTransform(D3DTRANSFORMSTATE_WORLD, &matIdentity); // only need to change _WORLD xform, _VIEW xform is Identity @@ -2720,7 +2701,7 @@ draw_multitri(Geom *geom, D3DPRIMITIVETYPE trilisttype) { dps_data.textureCoords[0].lpvData = (VOID*)(((char*) dps_data.textureCoords[0].lpvData) + cCurNumStripVerts*dps_data.textureCoords[0].dwStride); } - _pCurFvfBufPtr = NULL; + nassertv(_pCurFvfBufPtr == NULL); } } @@ -3024,38 +3005,7 @@ draw_sphere(GeomSphere *geom, GeomContext *gc) { _pCurFvfBufPtr = NULL; } -//////////////////////////////////////////////////////////////////// -// Function: GLGraphicsStateGuardian::issue_color_transform -// Access: Public, Virtual -// Description: -//////////////////////////////////////////////////////////////////// -void DXGraphicsStateGuardian:: -issue_color_transform(const ColorMatrixAttribute *attrib) { - _current_color_mat = attrib->get_matrix(); - if (_current_color_mat == LMatrix4f::ident_mat()) { // couldnt we a single ptr instead of doing full comparison - _color_transform_enabled = false; - } else { - _color_transform_enabled = true; - } -} - -//////////////////////////////////////////////////////////////////// -// Function: GLGraphicsStateGuardian::issue_alpha_transform -// Access: Public, Virtual -// Description: -//////////////////////////////////////////////////////////////////// -void DXGraphicsStateGuardian:: -issue_alpha_transform(const AlphaTransformAttribute *attrib) { - _current_alpha_offset= attrib->get_offset(); - _current_alpha_scale = attrib->get_scale(); - - if ((_current_alpha_offset == 0.0f) && (_current_alpha_scale == 1.0f)) { - _alpha_transform_enabled = false; - } else { - _alpha_transform_enabled = true; - } -} //////////////////////////////////////////////////////////////////// // Function: DXGraphicsStateGuardian::prepare_texture @@ -4091,8 +4041,6 @@ issue_tex_matrix(const TexMatrixAttribute *attrib) { #endif // WBD_GL_MODE } -#if 1 - //////////////////////////////////////////////////////////////////// // Function: DXGraphicsStateGuardian::issue_color // Access: Public, Virtual @@ -4100,14 +4048,66 @@ issue_tex_matrix(const TexMatrixAttribute *attrib) { //////////////////////////////////////////////////////////////////// void DXGraphicsStateGuardian:: issue_color(const ColorAttribute *attrib) { - if (attrib->is_on()&& attrib->is_real()) { - _issued_color_enabled = true; - Colorf c = attrib->get_color(); - _issued_color = Colorf_to_D3DCOLOR(c); - } else _issued_color_enabled = false; + + bool bAttribOn=attrib->is_on(); + bool bIsReal = attrib->is_real(); + + _issued_color_enabled = bAttribOn; + + // if an active unreal color is set, disable all color + _enable_all_color = !(bAttribOn && (!bIsReal)); + + if(bAttribOn && bIsReal) { + _issued_color = attrib->get_color(); + if(_color_transform_enabled || _alpha_transform_enabled) { + transform_color(_issued_color, _issued_color_D3DCOLOR); + } else { + _issued_color_D3DCOLOR = Colorf_to_D3DCOLOR(_issued_color); + } + } } -#endif +//////////////////////////////////////////////////////////////////// +// Function: DXGraphicsStateGuardian::issue_color_transform +// Access: Public, Virtual +// Description: +//////////////////////////////////////////////////////////////////// +void DXGraphicsStateGuardian:: +issue_color_transform(const ColorMatrixAttribute *attrib) { + _current_color_mat = attrib->get_matrix(); + + // couldnt we compare a single ptr instead of doing full comparison? + // bugbug: the ColorMatrixAttribute needs to be an On/Off attribute + // so we dont have to do this comparison + if (_current_color_mat == LMatrix4f::ident_mat()) { + _color_transform_enabled = false; + } else { + _color_transform_enabled = true; + if(_issued_color_enabled) { + transform_color(_issued_color, _issued_color_D3DCOLOR); + } + } +} + +//////////////////////////////////////////////////////////////////// +// Function: DXGraphicsStateGuardian::issue_alpha_transform +// Access: Public, Virtual +// Description: +//////////////////////////////////////////////////////////////////// +void DXGraphicsStateGuardian:: +issue_alpha_transform(const AlphaTransformAttribute *attrib) { + _current_alpha_offset = attrib->get_offset(); + _current_alpha_scale = attrib->get_scale(); + + if ((_current_alpha_offset == 0.0f) && (_current_alpha_scale == 1.0f)) { + _alpha_transform_enabled = false; + } else { + _alpha_transform_enabled = true; + if(_issued_color_enabled) { + transform_color(_issued_color, _issued_color_D3DCOLOR); + } + } +} //////////////////////////////////////////////////////////////////// // Function: DXGraphicsStateGuardian::issue_texture @@ -4116,7 +4116,6 @@ issue_color(const ColorAttribute *attrib) { //////////////////////////////////////////////////////////////////// void DXGraphicsStateGuardian:: issue_texture(const TextureAttribute *attrib) { - if (attrib->is_on()) { enable_texturing(true); Texture *tex = attrib->get_texture(); @@ -4784,7 +4783,7 @@ issue_linesmooth(const LinesmoothAttribute *attrib) { //////////////////////////////////////////////////////////////////// INLINE bool DXGraphicsStateGuardian:: wants_normals() const { - return(_lighting_enabled || _normals_enabled); + return (_lighting_enabled || _normals_enabled); } //////////////////////////////////////////////////////////////////// @@ -4797,30 +4796,6 @@ wants_texcoords() const { return _texturing_enabled; } -//////////////////////////////////////////////////////////////////// -// Function: DXGraphicsStateGuardian::wants_colors -// Access: Public, Virtual -// Description: Returns true if the GSG should issue geometry color -// commands, false otherwise. -//////////////////////////////////////////////////////////////////// -INLINE bool DXGraphicsStateGuardian:: -wants_colors() const { - // If we have scene graph color enabled, return false to indicate we - // shouldn't bother issuing geometry color commands. - - const ColorAttribute *catt; - if (!get_attribute_into(catt, _state, ColorTransition::get_class_type())) { - // No scene graph color at all. - return true; - } - - // We should issue geometry colors only if the scene graph color is off. - if (catt->is_off() || (!catt->is_real())) - return true; - - return false; -} - //////////////////////////////////////////////////////////////////// // Function: DXGraphicsStateGuardian::begin_decal // Access: Public, Virtual diff --git a/panda/src/dxgsg/dxGraphicsStateGuardian.h b/panda/src/dxgsg/dxGraphicsStateGuardian.h index 9a66a9741d..fee364c60a 100644 --- a/panda/src/dxgsg/dxGraphicsStateGuardian.h +++ b/panda/src/dxgsg/dxGraphicsStateGuardian.h @@ -324,11 +324,10 @@ protected: D3DBLEND _blend_source_func; D3DBLEND _blend_dest_func; -// int _pack_alignment; -// int _unpack_alignment; - bool _issued_color_enabled; // WBD ADDED - D3DCOLOR _issued_color; // WBD ADDED + bool _enable_all_color; + Colorf _issued_color; // WBD ADDED + D3DCOLOR _issued_color_D3DCOLOR; // WBD ADDED D3DSHADEMODE _CurShadeMode; diff --git a/panda/src/dxgsg/dxTextureContext.cxx b/panda/src/dxgsg/dxTextureContext.cxx index f527a94669..5d85038cec 100644 --- a/panda/src/dxgsg/dxTextureContext.cxx +++ b/panda/src/dxgsg/dxTextureContext.cxx @@ -36,11 +36,11 @@ char *ConvNameStrs[] = {"None","Conv32to32","Conv32to32_NoAlpha","Conv32to24","C "ConvLum16to32","ConvLum16to16","ConvLum8to8","ConvLum8to24","ConvLum8to32", "ConvLum8to16_0555","ConvLum8to16_0565","ConvAlpha8to16_4444","ConvAlpha8to32","ConvAlpha8to8" }; +#endif char *PandaFilterNameStrs[] = {"FT_nearest","FT_linear","FT_nearest_mipmap_nearest","FT_linear_mipmap_nearest", "FT_nearest_mipmap_linear", "FT_linear_mipmap_linear" }; -#endif TypeHandle DXTextureContext::_type_handle; @@ -1499,14 +1499,15 @@ CreateTexture(LPDIRECT3DDEVICE7 pd3dDevice, int cNumTexPixFmts, LPDDPIXELFORMAT case Texture::FT_linear_mipmap_linear: _bHasMipMaps=TRUE; } -#ifdef _DEBUG - if(dx_mipmap_everything) { // debug toggle + + if(dx_mipmap_everything) { // debug toggle, ok to leave in since its just a creation cost _bHasMipMaps=TRUE; + if(ft != Texture::FT_linear_mipmap_linear) { + dxgsg_cat.spam() << "Forcing mipmap filtering on DX texture [" << _tex->get_name() << "]\n"; + } ft = Texture::FT_linear_mipmap_linear; - _tex->set_magfilter(ft); _tex->set_minfilter(ft); } -#endif } else if((ft==Texture::FT_nearest_mipmap_nearest) || // cvt to no-mipmap filter types (ft==Texture::FT_nearest_mipmap_linear)) { ft=Texture::FT_nearest; @@ -1872,11 +1873,11 @@ DeleteTexture( ) { DXTextureContext:: DXTextureContext(Texture *tex) : TextureContext(tex) { -#ifdef _DEBUG - if(dxgsg_cat.is_spam()) { +//#ifdef NDEBUG +// if(dxgsg_cat.is_spam()) { dxgsg_cat.spam() << "Creating DX texture [" << tex->get_name() << "], minfilter(" << PandaFilterNameStrs[tex->get_minfilter()] << "), magfilter("<get_magfilter()] << "), anisodeg(" << tex->get_anisotropic_degree() << ")\n"; - } -#endif +// } +//#endif _surface = NULL; _bHasMipMaps = FALSE; _tex = tex;