2. Summary
  3. Files
  4. Support
  5. Report Spam
  6. Create account
  7. Log in

Changeset 2341

Show
Ignore:
Timestamp:
12/18/10 12:57:36 (2 years ago)
Author:
borrillis
Message:

More XNA 4.0 fixes

started implementation of GraphicsProfile? -> HardwareCapabilities?

Files:
1 modified

Legend:

Unmodified
Added
Removed

  • trunk/Projects/Axiom/RenderSystems/XNA/Source/XnaRenderSystem.cs

    r2339 r2341  
    8080                private Driver _activeDriver; 
    8181 
    82                 private XFG.GraphicsDeviceCapabilities _capabilities; 
     82                //private XFG.GraphicsDeviceCapabilities _capabilities; 
    8383                /// Saved last view matrix 
    8484                protected Matrix4 _viewMatrix = Matrix4.Identity; 
    … …  
    113113                private bool _useNVPerfHUD; 
    114114                private bool _vSync; 
    115                 private XFG.MultiSampleType _fsaaType = XFG.MultiSampleType.None; 
     115                //private XFG.MultiSampleType _fsaaType = XFG.MultiSampleType.None; 
    116116                private int _fsaaQuality = 0; 
    117117 
    … …  
    151151 
    152152                        // TODO: Optimize to remove enumeration if possible, although with so few iterations it may never make a difference 
     153                        var xnaBindings = new XFG.VertexBufferBinding[ binding.BindingCount ]; 
     154                        int index = 0; 
    153155                        foreach ( short stream in bindings.Keys ) 
    154156                        { 
    155157                                XnaHardwareVertexBuffer buffer = (XnaHardwareVertexBuffer)bindings[ stream ]; 
    156  
    157                                 _device.Vertices[ stream ].SetSource( buffer.XnaVertexBuffer, 0, buffer.VertexSize ); 
    158  
    159                                 _lastVertexSourceCount++; 
    160                         } 
    161  
    162                         // Unbind any unused sources 
    163                         for ( int i = binding.BindingCount; i < _lastVertexSourceCount; i++ ) 
    164                         { 
    165                                 _device.Vertices[ i ].SetSource( null, 0, 0 ); 
    166                         } 
    167  
    168                         _lastVertexSourceCount = binding.BindingCount; 
     158                                xnaBindings[index++] = new XFG.VertexBufferBinding( buffer.XnaVertexBuffer ); 
     159                        } 
     160 
     161                        _device.SetVertexBuffers( xnaBindings ); 
    169162                } 
    170163 
    … …  
    177170                        XnaVertexDeclaration vertDecl = (XnaVertexDeclaration)decl; 
    178171 
    179                         _device.VertexDeclaration = vertDecl.XnaVertexDecl; 
     172                        //_device.VertexDeclaration = vertDecl.XnaVertexDecl; 
    180173                } 
    181174 
    … …  
    210203                                } 
    211204                        } 
    212  
     205/* 
    213206                        if ( name == "Anti aliasing" ) 
    214207                        { 
    … …  
    235228                                        _setFSAA( fsaa, level ); 
    236229                                } 
    237                         } 
    238  
     230  
     231                        } 
     232*/ 
    239233                        if ( name == "VSync" ) 
    240234                        { 
    … …  
    253247 
    254248                } 
    255  
     249/* 
    256250                private void _setFSAA( XFG.MultiSampleType fsaa, int level ) 
    257251                { 
    … …  
    262256                        } 
    263257                } 
    264  
     258*/ 
    265259                private void _initConfigOptions() 
    266260                { 
    … …  
    463457                ///             Helper method to go through and interrogate hardware capabilities. 
    464458                /// </summary> 
    465                 private void _checkHardwareCapabilities( XFG.GraphicsDevice device ) 
     459                private void _checkHardwareCapabilities( XFG.GraphicsProfile profile ) 
     460                { 
     461                        _setCapabilitiesForAllProfiles(); 
     462 
     463                        if ( profile == XFG.GraphicsProfile.HiDef ) 
     464                        { 
     465                                _setCapabilitiesForHiDefProfile(); 
     466                        } 
     467                        else if( profile == XFG.GraphicsProfile.Reach ) 
     468                        { 
     469                                _setCapabilitiesForReachProfile(); 
     470                        } 
     471                } 
     472 
     473                private void _setCapabilitiesForAllProfiles() 
     474                { 
     475                        // Texture Compression 
     476                        // We always support compression, Xna will decompress if device does not support 
     477                        HardwareCapabilities.SetCapability( Capabilities.TextureCompression ); 
     478                        HardwareCapabilities.SetCapability( Capabilities.TextureCompressionDXT ); 
     479 
     480                        // Xna uses vertex buffers for everything 
     481                        HardwareCapabilities.SetCapability( Capabilities.VertexBuffer ); 
     482 
     483                        // blending between stages is definitely supported 
     484                        HardwareCapabilities.SetCapability( Capabilities.TextureBlending ); 
     485                        HardwareCapabilities.SetCapability( Capabilities.MultiTexturing ); 
     486 
     487                } 
     488                private void _setCapabilitiesForHiDefProfile() 
     489                { 
     490                        // Fill in the HiDef profile requirements. 
     491 
     492                        HardwareCapabilities.SetCapability( Capabilities.HardwareOcculusion ); 
     493 
     494                        //VertexShaderVersion = 0x300; 
     495                        HardwareCapabilities.SetCapability( Capabilities.VertexPrograms ); 
     496                        HardwareCapabilities.MaxVertexProgramVersion = "vs_3_0"; 
     497                        HardwareCapabilities.VertexProgramConstantIntCount = 16 * 4; 
     498                        HardwareCapabilities.VertexProgramConstantFloatCount = 256; 
     499                        this.gpuProgramMgr.PushSyntaxCode( "vs_1_1" ); 
     500                        this.gpuProgramMgr.PushSyntaxCode( "vs_2_0" ); 
     501                        this.gpuProgramMgr.PushSyntaxCode( "vs_2_x" ); 
     502                        this.gpuProgramMgr.PushSyntaxCode( "vs_3_0" ); 
     503 
     504                        //PixelShaderVersion = 0x300; 
     505                        HardwareCapabilities.SetCapability( Capabilities.FragmentPrograms ); 
     506                        HardwareCapabilities.MaxFragmentProgramVersion = "ps_3_0"; 
     507                        HardwareCapabilities.FragmentProgramConstantIntCount = 16; 
     508                        HardwareCapabilities.FragmentProgramConstantFloatCount = 224; 
     509                        this.gpuProgramMgr.PushSyntaxCode( "ps_1_1" ); 
     510                        this.gpuProgramMgr.PushSyntaxCode( "ps_1_2" ); 
     511                        this.gpuProgramMgr.PushSyntaxCode( "ps_1_3" ); 
     512                        this.gpuProgramMgr.PushSyntaxCode( "ps_1_4" ); 
     513                        this.gpuProgramMgr.PushSyntaxCode( "ps_2_0" ); 
     514                        this.gpuProgramMgr.PushSyntaxCode( "ps_3_0" ); 
     515                                                 
     516                        //SeparateAlphaBlend = true; 
     517                        HardwareCapabilities.SetCapability( Capabilities.AdvancedBlendOperations ); 
     518                        //DestBlendSrcAlphaSat = true; 
     519                         
     520                        //MaxPrimitiveCount = 1048575; 
     521                        //IndexElementSize32 = true; 
     522                        //MaxVertexStreams = 16; 
     523                        //MaxStreamStride = 255; 
     524                         
     525                        //MaxTextureSize = 4096; 
     526                        //MaxCubeSize = 4096; 
     527                        //MaxVolumeExtent = 256; 
     528                        //MaxTextureAspectRatio = 2048; 
     529                        //MaxVertexSamplers = 4; 
     530                        //MaxRenderTargets = 4; 
     531                        HardwareCapabilities.MultiRenderTargetCount = 4; 
     532 
     533                        //NonPow2Unconditional = true; 
     534                        //NonPow2Cube = true; 
     535                        //NonPow2Volume = true; 
     536 
     537                        //ValidTextureFormats       = MakeList(STANDARD_TEXTURE_FORMATS, COMPRESSED_TEXTURE_FORMATS, SIGNED_TEXTURE_FORMATS, HIDEF_TEXTURE_FORMATS, FLOAT_TEXTURE_FORMATS); 
     538                        //ValidCubeFormats          = MakeList(STANDARD_TEXTURE_FORMATS, COMPRESSED_TEXTURE_FORMATS, HIDEF_TEXTURE_FORMATS, FLOAT_TEXTURE_FORMATS); 
     539                        //ValidVolumeFormats        = MakeList(STANDARD_TEXTURE_FORMATS, HIDEF_TEXTURE_FORMATS, FLOAT_TEXTURE_FORMATS); 
     540                        //ValidVertexTextureFormats = MakeList(FLOAT_TEXTURE_FORMATS); 
     541                        //InvalidFilterFormats      = MakeList(FLOAT_TEXTURE_FORMATS); 
     542                        //InvalidBlendFormats       = MakeList(STANDARD_FLOAT_TEXTURE_FORMATS); 
     543                        //ValidVertexFormats        = MakeList(STANDARD_VERTEX_FORMATS, HIDEF_VERTEX_FORMATS); 
     544 
     545                } 
     546 
     547                private void _setCapabilitiesForReachProfile() 
     548                { 
     549                        // Fill in the Reach profile requirements. 
     550                        // Texture Compression 
     551                        // We always support compression, Xna will decompress if device does not support 
     552                        HardwareCapabilities.SetCapability( Capabilities.TextureCompression ); 
     553                        HardwareCapabilities.SetCapability( Capabilities.TextureCompressionDXT ); 
     554 
     555                        // Xna uses vertex buffers for everything 
     556                        HardwareCapabilities.SetCapability( Capabilities.VertexBuffer ); 
     557 
     558 
     559                        //VertexShaderVersion = 0x200; 
     560                        HardwareCapabilities.SetCapability( Capabilities.VertexPrograms ); 
     561                        HardwareCapabilities.MaxVertexProgramVersion = "vs_2_0"; 
     562                        HardwareCapabilities.VertexProgramConstantIntCount = 16 * 4; 
     563                        HardwareCapabilities.VertexProgramConstantFloatCount = 256; 
     564                        this.gpuProgramMgr.PushSyntaxCode( "vs_1_1" ); 
     565                        this.gpuProgramMgr.PushSyntaxCode( "vs_2_0" ); 
     566 
     567                        //PixelShaderVersion = 0x200; 
     568                        HardwareCapabilities.SetCapability( Capabilities.FragmentPrograms ); 
     569                        HardwareCapabilities.MaxFragmentProgramVersion = "ps_2_0"; 
     570                        HardwareCapabilities.FragmentProgramConstantIntCount = 0; 
     571                        HardwareCapabilities.FragmentProgramConstantFloatCount = 32; 
     572                        this.gpuProgramMgr.PushSyntaxCode( "ps_1_1" ); 
     573                        this.gpuProgramMgr.PushSyntaxCode( "ps_1_2" ); 
     574                        this.gpuProgramMgr.PushSyntaxCode( "ps_1_3" ); 
     575                        this.gpuProgramMgr.PushSyntaxCode( "ps_1_4" ); 
     576                        this.gpuProgramMgr.PushSyntaxCode( "ps_2_0" ); 
     577                         
     578                        //SeparateAlphaBlend = false; 
     579                        //DestBlendSrcAlphaSat = false; 
     580 
     581                        //MaxPrimitiveCount = 65535; 
     582                        //IndexElementSize32 = false; 
     583                        //MaxVertexStreams = 16; 
     584                        //MaxStreamStride = 255; 
     585                         
     586                        //MaxTextureSize = 2048; 
     587                        //MaxCubeSize = 512; 
     588                        //MaxVolumeExtent = 0; 
     589                        //MaxTextureAspectRatio = 2048; 
     590                        //MaxVertexSamplers = 0; 
     591                        //MaxRenderTargets = 1; 
     592                        HardwareCapabilities.MultiRenderTargetCount = 1; 
     593                         
     594                        //NonPow2Unconditional = false; 
     595                        //NonPow2Cube = false; 
     596                        //NonPow2Volume = false; 
     597 
     598                        //ValidTextureFormats       = MakeList(STANDARD_TEXTURE_FORMATS, COMPRESSED_TEXTURE_FORMATS, SIGNED_TEXTURE_FORMATS); 
     599                        //ValidCubeFormats          = MakeList(STANDARD_TEXTURE_FORMATS, COMPRESSED_TEXTURE_FORMATS); 
     600                        //ValidVolumeFormats        = MakeList<SurfaceFormat>(); 
     601                        //ValidVertexTextureFormats = MakeList<SurfaceFormat>(); 
     602                        //InvalidFilterFormats      = MakeList<SurfaceFormat>(); 
     603                        //InvalidBlendFormats       = MakeList<SurfaceFormat>(); 
     604                        //ValidVertexFormats        = MakeList(STANDARD_VERTEX_FORMATS); 
     605                } 
     606 
     607                /* 
     608                private void unusedcode() 
    466609                { 
    467610                        _capabilities = _device.GraphicsDeviceCapabilities; 
    … …  
    473616                        HardwareCapabilities.MaxLights = 8; 
    474617 
    475             XFG.RenderTargetBinding rtb = null; 
    476  
    477             //KLUDGE to get the first item 
    478             foreach (var item in _device.GetRenderTargets()) 
    479             { 
    480                 rtb = item; 
    481                 break; 
    482             } 
    483  
    484             XFG.RenderTarget2D surface = (XFG.RenderTarget2D)rtb.RenderTarget; 
     618                        XFG.RenderTargetBinding rtb = null; 
     619 
     620                        //KLUDGE to get the first item 
     621                        foreach ( var item in _device.GetRenderTargets() ) 
     622                        { 
     623                                rtb = item; 
     624                                break; 
     625                        } 
     626 
     627                        XFG.RenderTarget2D surface = (XFG.RenderTarget2D)rtb.RenderTarget; 
    485628 
    486629                        if ( surface.DepthStencilFormat == XFG.DepthFormat.Depth24Stencil8 || surface.DepthStencilFormat == XFG.DepthFormat.Depth24 ) 
    … …  
    509652                        } 
    510653 
    511                         // blending between stages is definately supported 
    512                         HardwareCapabilities.SetCapability( Capabilities.TextureBlending ); 
    513                         HardwareCapabilities.SetCapability( Capabilities.MultiTexturing ); 
    514654 
    515655                        // Dot3 bump mapping? 
    … …  
    525665                        } 
    526666 
    527                         // Texture Compression 
    528                         // We always support compression, Xna will decompress if device does not support 
    529                         HardwareCapabilities.SetCapability( Capabilities.TextureCompression ); 
    530                         HardwareCapabilities.SetCapability( Capabilities.TextureCompressionDXT ); 
    531  
    532                         // Xna uses vertex buffers for everything 
    533                         HardwareCapabilities.SetCapability( Capabilities.VertexBuffer ); 
    534  
    535667                        // Scissor test 
    536668                        if ( _capabilities.RasterCapabilities.SupportsScissorTest ) 
    … …  
    551683                        } 
    552684 
    553                         // Hardware Occlusion, new! 
    554             if (_device.GraphicsProfile == XFG.GraphicsProfile.HiDef) 
    555             { 
    556                 HardwareCapabilities.SetCapability(Capabilities.HardwareOcculusion); 
    557             } 
    558  
    559685 
    560686                        if ( _capabilities.MaxUserClipPlanes > 0 ) 
    … …  
    562688                                HardwareCapabilities.SetCapability( Capabilities.UserClipPlanes ); 
    563689                        } 
    564  
    565                         _checkVertexProgramCapabilities(); 
    566  
    567                         _checkFragmentProgramCapabilities(); 
    568690 
    569691                        // Infinite projection? 
    … …  
    589711                        HardwareCapabilities.Log(); 
    590712                } 
    591  
    592                 private void _checkFragmentProgramCapabilities() 
    593                 { 
    594                         int fpMajor = _capabilities.PixelShaderVersion.Major; 
    595                         int fpMinor = _capabilities.PixelShaderVersion.Minor; 
    596  
    597                         switch ( fpMajor ) 
    598                         { 
    599                                 case 1: 
    600                                         HardwareCapabilities.MaxFragmentProgramVersion = string.Format( "ps_1_{0}", fpMinor ); 
    601  
    602                                         HardwareCapabilities.FragmentProgramConstantIntCount = 0; 
    603                                         // 8 4d float values, entered as floats but stored as fixed 
    604                                         HardwareCapabilities.FragmentProgramConstantFloatCount = 8; 
    605                                         break; 
    606  
    607                                 case 2: 
    608                                         if ( fpMinor > 0 ) 
    609                                         { 
    610                                                 HardwareCapabilities.MaxFragmentProgramVersion = "ps_2_x"; 
    611                                                 //16 integer params allowed 
    612                                                 HardwareCapabilities.FragmentProgramConstantIntCount = 16 * 4; 
    613                                                 // 4d float params 
    614                                                 HardwareCapabilities.FragmentProgramConstantFloatCount = 224; 
    615                                         } 
    616                                         else 
    617                                         { 
    618                                                 HardwareCapabilities.MaxFragmentProgramVersion = "ps_2_0"; 
    619                                                 // no integer params allowed 
    620                                                 HardwareCapabilities.FragmentProgramConstantIntCount = 0; 
    621                                                 // 4d float params 
    622                                                 HardwareCapabilities.FragmentProgramConstantFloatCount = 32; 
    623                                         } 
    624  
    625                                         break; 
    626  
    627                                 case 3: 
    628                                         if ( fpMinor > 0 ) 
    629                                         { 
    630                                                 HardwareCapabilities.MaxFragmentProgramVersion = "ps_3_x"; 
    631                                         } 
    632                                         else 
    633                                         { 
    634                                                 HardwareCapabilities.MaxFragmentProgramVersion = "ps_3_0"; 
    635                                         } 
    636  
    637                                         // 16 integer params allowed 
    638                                         HardwareCapabilities.FragmentProgramConstantIntCount = 16; 
    639                                         HardwareCapabilities.FragmentProgramConstantFloatCount = 224; 
    640                                         break; 
    641  
    642                                 default: 
    643                                         // doh, SOL 
    644                                         HardwareCapabilities.MaxFragmentProgramVersion = ""; 
    645                                         break; 
    646                         } 
    647  
    648                         // Fragment Program syntax code checks 
    649                         if ( fpMajor >= 1 ) 
    650                         { 
    651                                 HardwareCapabilities.SetCapability( Capabilities.FragmentPrograms ); 
    652                                 this.gpuProgramMgr.PushSyntaxCode( "ps_1_1" ); 
    653  
    654                                 if ( fpMajor > 1 || fpMinor >= 2 ) 
    655                                 { 
    656                                         this.gpuProgramMgr.PushSyntaxCode( "ps_1_2" ); 
    657                                 } 
    658                                 if ( fpMajor > 1 || fpMinor >= 3 ) 
    659                                 { 
    660                                         this.gpuProgramMgr.PushSyntaxCode( "ps_1_3" ); 
    661                                 } 
    662                                 if ( fpMajor > 1 || fpMinor >= 4 ) 
    663                                 { 
    664                                         this.gpuProgramMgr.PushSyntaxCode( "ps_1_4" ); 
    665                                 } 
    666                         } 
    667  
    668                         if ( fpMajor >= 2 ) 
    669                         { 
    670                                 this.gpuProgramMgr.PushSyntaxCode( "ps_2_0" ); 
    671  
    672                                 if ( fpMinor > 0 ) 
    673                                 { 
    674                                         this.gpuProgramMgr.PushSyntaxCode( "ps_2_x" ); 
    675                                 } 
    676                         } 
    677  
    678                         if ( fpMajor >= 3 ) 
    679                         { 
    680                                 this.gpuProgramMgr.PushSyntaxCode( "ps_3_0" ); 
    681  
    682                                 if ( fpMinor > 0 ) 
    683                                 { 
    684                                         this.gpuProgramMgr.PushSyntaxCode( "ps_3_x" ); 
    685                                 } 
    686                         } 
    687                 } 
    688  
    689                 private void _checkVertexProgramCapabilities() 
    690                 { 
    691                         int vpMajor = _capabilities.VertexShaderVersion.Major; 
    692                         int vpMinor = _capabilities.VertexShaderVersion.Minor; 
    693  
    694                         // check vertex program HardwareCapabilities 
    695                         switch ( vpMajor ) 
    696                         { 
    697                                 case 1: 
    698                                         HardwareCapabilities.MaxVertexProgramVersion = "vs_1_1"; 
    699                                         // 4d float vectors 
    700                                         HardwareCapabilities.VertexProgramConstantFloatCount = _capabilities.MaxVertexShaderConstants; 
    701                                         // no int params supports 
    702                                         HardwareCapabilities.VertexProgramConstantIntCount = 0; 
    703                                         break; 
    704                                 case 2: 
    705                                         if ( vpMinor > 0 ) 
    706                                         { 
    707                                                 HardwareCapabilities.MaxVertexProgramVersion = "vs_2_x"; 
    708                                         } 
    709                                         else 
    710                                         { 
    711                                                 HardwareCapabilities.MaxVertexProgramVersion = "vs_2_0"; 
    712                                         } 
    713  
    714                                         // 16 ints 
    715                                         HardwareCapabilities.VertexProgramConstantIntCount = 16 * 4; 
    716                                         // 4d float vectors 
    717                                         HardwareCapabilities.VertexProgramConstantFloatCount = _capabilities.MaxVertexShaderConstants; 
    718  
    719                                         break; 
    720                                 case 3: 
    721                                         HardwareCapabilities.MaxVertexProgramVersion = "vs_3_0"; 
    722  
    723                                         // 16 ints 
    724                                         HardwareCapabilities.VertexProgramConstantIntCount = 16 * 4; 
    725                                         // 4d float vectors 
    726                                         HardwareCapabilities.VertexProgramConstantFloatCount = _capabilities.MaxVertexShaderConstants; 
    727  
    728                                         break; 
    729                                 default: 
    730                                         // not gonna happen 
    731                                         HardwareCapabilities.MaxVertexProgramVersion = ""; 
    732                                         break; 
    733                         } 
    734  
    735                         // check for supported vertex program syntax codes 
    736                         if ( vpMajor >= 1 ) 
    737                         { 
    738                                 HardwareCapabilities.SetCapability( Capabilities.VertexPrograms ); 
    739                                 this.gpuProgramMgr.PushSyntaxCode( "vs_1_1" ); 
    740                         } 
    741                         if ( vpMajor >= 2 ) 
    742                         { 
    743                                 if ( vpMajor > 2 || vpMinor > 0 ) 
    744                                 { 
    745                                         this.gpuProgramMgr.PushSyntaxCode( "vs_2_x" ); 
    746                                 } 
    747                                 this.gpuProgramMgr.PushSyntaxCode( "vs_2_0" ); 
    748                         } 
    749                         if ( vpMajor >= 3 ) 
    750                         { 
    751                                 this.gpuProgramMgr.PushSyntaxCode( "vs_3_0" ); 
    752                         } 
    753                 } 
    754  
     713                */ 
    755714                private XNA.Matrix _makeXnaMatrix( Axiom.Math.Matrix4 matrix ) 
    756715                { 
    … …  
    23972356                                } 
    23982357 
    2399                                 if (depth.Format == _device.DepthStencilBuffer.Format) 
     2358                                if ( depth.Format == _device.DepthStencilBuffer.Format ) 
    24002359                                { 
    24012360                                        /*MessageBox.Show("same:\n" +  

© 2013 SourceForge. All Rights Reserved. SourceForge is a Dice Holdings, Inc. company   Terms of Use - Privacy Policy - Cookies/Opt Out