;;; Default blend efficiencies.
;;; Heavily favor GPU skinning for unknown hardware.
SETTINGS {
    CPUVertexBlendEfficiency = 1.0
    GPUVertexShaderPerfRating = 4.0
    GPUTLPerfRating = 1.0

    ; This tells Alchemy to release its references to images
    ; once they are loaded into texture memory.  The only draw-back
    ; to doing this is that igVisualContext::getTextureSource() no longer
    ; works.
    discardOriginalTextureImages = true

    ; Enable texture pooling in the visual context.  Configure the pool to hold
    ; at most 128 textures and accept textures no smaller than 32x32 and no
    ; larger than 256x256.
    enableTexturePooling = true
    texturePoolCapacity = 128
    texturePoolMinDimension = 32
    texturePoolMaxDimension = 256

    ; Enable hardware compression for images.
    Render/hardwareTextureCompression = true
    ; Use un-simplified water shader for desktop
    Render/useSimplifiedWaterShader=false

    useSoftwareVertexBlendingForCustomShaders = false

    ; This controls the building parameters if performance quality
    ; is enabled. It is disabled by default.
    PerformanceQuality/minNumBuildings = 50
    PerformanceQuality/minBuildingPerfScore = 0.5
    PerformanceQuality/maxNumBuildings = 150
    PerformanceQuality/maxBuildingPerfScore = 2.0
    PerformanceQuality/buildingScalingPower  = 1

    Maps/docsAutoUploadEnabled = true
}

CPU_VENDOR = amd {
    CPU_TYPE >= athlon {
        SETTINGS {
            CPUVertexBlendEfficiency = 1.0
    }}
}
CPU_VENDOR = intel {
    CPU_TYPE >= pentium_3 {
        SETTINGS {
            CPUVertexBlendEfficiency = 1.0
    }}
    CPU_TYPE >= pentium_4 {
        SETTINGS {
            CPUVertexBlendEfficiency = 1.2
    }}
}


;;;;;;;;;
; Turn on line and point smoothing for workstation OGL cards.
VENDOR >= ATI {
    CHIPSET >= ATI Fire {
        SETTINGS {
            Render/pointAndLineSmoothEnable = true
    }}
    CHIPSET >= Fire {
        SETTINGS {
            Render/pointAndLineSmoothEnable = true
    }}
    CHIPSET >= ATI MOBILITY FIRE {
        SETTINGS {
            Render/pointAndLineSmoothEnable = true
    }}
    CHIPSET >= MOBILITY Fire {
        SETTINGS {
            Render/pointAndLineSmoothEnable = true
    }}
}
VENDOR >= NVIDIA {
    CHIPSET >= Quadro {
        SETTINGS {
            Render/pointAndLineSmoothEnable = true
    }}
    CHIPSET >= NVIDIA Quadro {
        SETTINGS {
            Render/pointAndLineSmoothEnable = true
    }}
}

OS = linux {
    SETTINGS {
        onlyOGL = true

        ; Use GLSL shaders and fixed-function in Alchemy emulation.
        ; Platforms that don't support GLSL will fall back to ARB shaders
        ; and/or normal OGL fixed-function.
        emulateFixedFunctionWithGL2Shaders = true
        Render/enableGLSLShaders = true
    }

    ; OpenGl version 2.0 or newer is needed for GLSL shaders, so display an
    ; error message if only version 1.x is available.
    ; NOTE: PLATFORM_VERSION is checked using a string compare (as opposed
    ; to a numerical compare).  The >= operator checks that the version
    ; string begins with "1.".
    PLATFORM_VERSION >= 1. {
        SETTINGS {
            cantRun = true
        }
    }

    ; Check for Software Mesa...
    VENDOR >= Mesa {
        SETTINGS {
            OGLsoftwareEmulated = true
            WaterSurface/waterSurfaceUsingShaders = false
            Precipitation/usePrecipitationShader = false
            SpeedTree/useBillboardsOnly = true
            Terrain/fadeTextureLod = false
            ; Turn off VBO support for OGL for Mesa.
            enableVertexBufferObjects = false
        }
    }

    ; Brian Paul wrote Mesa, some versions have him as the GL_VENDOR string.
    VENDOR >= Brian Paul {
        SETTINGS {
            OGLsoftwareEmulated = true
            WaterSurface/waterSurfaceUsingShaders = false
            Precipitation/usePrecipitationShader = false
            SpeedTree/useBillboardsOnly = true
            Terrain/fadeTextureLod = false
            ; Turn off VBO support for OGL for Mesa.
            enableVertexBufferObjects = false
        }
    }

    VENDOR >= ATI {
        SETTINGS {
            ; P.S. 2/20/07
            ; Enable mipmaps by default on all ATI cards.
            enableMipmaps = true
            ; Turn on VBO support for OGL for ati and nvidia.
            enableVertexBufferObjects = true
            ; Only use VBOs for some of the vertex arrays.
            geometryUsesVBOByDefault = false
        }
    }
    VENDOR >= NVIDIA {
        SETTINGS {
            ; P.S. 2/20/07
            ; Enable mipmaps by default on all nVidia cards.
            enableMipmaps = true
            ; Turn on VBO support for OGL for ati and nvidia.
            enableVertexBufferObjects = true
            ; Only use VBOs for some of the vertex arrays.
            geometryUsesVBOByDefault = false
        }
    }
    VENDOR >= Intel {
        SETTINGS {
            WaterSurface/waterSurfaceUsingShaders = false
            Precipitation/usePrecipitationShader = false
            SpeedTree/useBillboardsOnly = true
            Terrain/fadeTextureLod = false
            ; Turn off VBO support for OGL for intel.. roads/labels do not showup.
            enableVertexBufferObjects = false
        }
    }

    ; Intel drivers show a 3rd party for the vendor string, but
    ; can be identified by "Mesa DRI Intel" in the chipset (at least
    ; for GM965 driver that was tested).
    CHIPSET >= Mesa DRI Intel {
        SETTINGS {
            ; B.A. 4/3/08
            ; Filled polygons are confirmed broken on an Intel GM965.
            ; This setting disables filled polygons for all Intel cards, which
            ; seems reasonable since most Intel cards also have problems
            ; drawing filled polygons on OGL Windows.  See bug #1096613.
            Render/fillPolysEnable = false
            ; Turn off VBO support for OGL.
            enableVertexBufferObjects = false
        }
    }
}

OS = macos {
    SETTINGS {
        onlyOGL = true
        enableMipmaps = true
        ; Turn off VBO support for OGL on Mac.
        enableVertexBufferObjects = false

        ; Use GLSL shaders and fixed-function in Alchemy emulation.
        ; Platforms that don't support GLSL will fall back to ARB shaders
        ; and/or normal OGL fixed-function.
        emulateFixedFunctionWithGL2Shaders = true
        Render/enableGLSLShaders = true
    }

    SETTINGS {
        ; The plugin on Mac is slower than on windows because it needs
        ; to do extra work (buffer copies, etc.).  Reduce the computed
        ; performance score by 40% to account for this.
        PerformanceQuality/systemPerfScoreScale = 0.6
    }

    VENDOR >= ATI {

        CHIPSET >= ATI Rage 128 Pro {
            SETTINGS {
                ; B.B. - 1/29/06
                ; economize as much as possible
                enableMipmaps = false

                ; B.B. - 1/29/06
                ; reduce VRAM strain
                Render/detailAreaMax = 256

                ; B.B. - 2/2/06
                ; based on the "Rage 128 OpenGL" failing
                Render/fillPolysEnable = false

                ; B.B. - 2/2/06
                ; based on Radeon 7000 failing
                Render/maxTextureSize = 1024

                ; B.B. - 2/6/06
                ; all text appears as white - labels, status bar and copyrights
                cantRun = true
        }}
        CHIPSET >= ATI Rage 128 OpenGL Engine {
            SETTINGS {
                ; B.B. - 2/2/06
                ; increase framerate - untested
                Render/detailAreaRec = 256

                ; B.B. - 2/4/06
                ; fill polys swaps channels in lower left corner - external testing
                ; reducing fillPolysMaxTex to 256 swapped channels across all tiles
                Render/fillPolysEnable = false
        }}
        CHIPSET >= ATI Radeon OpenGL Engine {
            SETTINGS {
                ; B.B. - 2/2/06
                ; copied from Radeon 7000 settings - untested
                Render/detailAreaRec = 256

                ; B.B. - 2/2/06
                ; based on external testing
                Render/maxTextureSize = 1024
        }}
        CHIPSET >= ATI Radeon 7000 {
            SETTINGS {
                ; B.B. - 1/31/06
                ; +40% on framerate, 1k works ok
                Render/detailAreaRec = 256

                ; B.B. - 1/31/06
                ; 2k textures fail, overlaps frame buffer
                ; remove the following line and load a 2k x 2k
                ; texture for really cool effects
                Render/maxTextureSize = 1024
        }}
        CHIPSET >= ATI Mobility Radeon 7500 {
        }
        CHIPSET >= ATI Radeon 8500 {   ; 64MB
            SETTINGS {
                ; B.B. - 2/8/06
                ; Occasionally locks computer on tilted views
                cantRun = true
        }}
        CHIPSET >= ATI Radeon 9200 {
            SETTINGS {
                WaterSurface/waterSurfaceUsingShaders = false
                Precipitation/usePrecipitationShader = false
                SpeedTree/useBillboardsOnly = true
                Terrain/fadeTextureLod = false
        }}
        CHIPSET >= ATI Radeon 9600 XT OpenGL Engine {
            SETTINGS {
                ; B.B. - 2/22/06
                ; 2k textures fail - reported by user
                Render/maxTextureSize = 1024
        }}
        CHIPSET >= ATI Radeon 9700 {
            SETTINGS {
                ; enable mipmaps on ATI Radeon cards
                enableMipmaps = true
        }}
        CHIPSET >= ATI Radeon 9800 {
            SETTINGS {
        }}
        CHIPSET >= ATI Radeon X1600 {
            SETTINGS {
                ; C.D. - 4/18/13
                ; stars are not textured properly
                Planet/starsStarSpritesEnable = false
        }}
    }



    VENDOR >= NVIDIA {

        CHIPSET >= NVIDIA GeForce 2 MX { ; 32MB
            SETTINGS {
                ; B.B. - 2/2/06
                ; based on external testing - no overlay is shown
                Render/maxTextureSize = 1024

                ; 'thick' lines limited to ~2 pixel width
        }}
        CHIPSET >= NVIDIA GeForce4 MX {
            SETTINGS {
                ; b/1636265
                enableMipmaps = false
                Render/maxTextureSize = 1024
        }}
        CHIPSET >= NVIDIA GeForce FX 5200 {
            SETTINGS {
              WaterSurface/waterSurfaceUsingShaders = false
              Precipitation/usePrecipitationShader = false

              SpeedTree/useBillboardsOnly = true

              Terrain/fadeTextureLod = false
        }}
    }

}


OS = win_nt {    ; win_nt, win_2k, win_xp...
    ;=============================================================================
    ; OPENGL
    ;=============================================================================

    PLATFORM = ogl {
        SETTINGS {
            ; Turn on VBO support for OGL.
            enableVertexBufferObjects = true
            ; Only use VBOs for some of the vertex arrays.
            geometryUsesVBOByDefault = false

            ; Use GLSL shaders and fixed-function in Alchemy emulation.
            ; Platforms that don't support GLSL will fall back to ARB shaders
            ; and/or normal OGL fixed-function.
            emulateFixedFunctionWithGL2Shaders = true
            Render/enableGLSLShaders = true
        }

        ; OpenGl version 2.0 or newer is needed for GLSL shaders, so force
        ; 1.X versions of OGL into DX mode.
        ; NOTE: PLATFORM_VERSION is checked using a string compare (as opposed
        ; to a numerical compare).  The >= operator checks that the version
        ; string begins with "1.".
        PLATFORM_VERSION >= 1. {
            SETTINGS {
                forceDX = true
            }
        }

        ; Cards that expose an OGL version less than 3.0 tend to be older, and
        ; will likely run better in DX mode.
        PLATFORM_VERSION >= 2. {
            SETTINGS {
                recommendDX = true
            }
        }

        GFX_CAPABILITY(IG_GFX_CAPABILITY_GL2_SHADERS_SUPPORTED) = 0 {
          SETTINGS {
            cantRun = true
            recommendDX = true
          }
        }

        VENDOR >= 3Dfx {
            SETTINGS {
                manufacturerUrl       = www.3dfx.com
                manufacturerDriverUrl = www.voodoofiles.com/3dfxhelp.asp

                ;
                ; imported from 3.0
                ;
                ; avoid
                noVAcolor = true
                ; never use 3dfx multitextures (broken in too many cases)
                maxTexStages = 1
            }
        }



        VENDOR >= 3Dlabs {
            SETTINGS {
                manufacturerUrl       = www.3dlabs.com
                manufacturerDriverUrl = www.3dlabs.com/support/drivers
            }

            CHIPSET = PERMIDIA2 {
                ; ** not mentioned in 3.0 - inherit defaults **
                SETTINGS {
                    ; avoid
                    noVAcolor = true
            }}
            CHIPSET >= WildCat {
                SETTINGS {
                    ; B.M. - 7/15/04
                    ; textures -> white with mipmaps on
            }}
            CHIPSET >= GLINT { ; Oxygen VX1
                SETTINGS {
                    ; A.P. - 6/10/06
                    ; OpenGL has vast issues
                    forceDX = true
            }}
        }



        VENDOR >= ATI {

            SETTINGS {
                manufacturerUrl       = www.ati.com
                manufacturerDriverUrl = www.ati.com/support

                ;
                ; imported from 3.0
                ;

                ; Radeon cards starting beginning with the 8500 fall into a slow path
                ; when putting vertex arrays in display lists
                noVertexArraysInDLists = true

                ; B.A. 2/23/07
                ; enable mipmaps on ATI cards
                enableMipmaps = true
            }

            ; B.B. 7/30/04 - device name not confirmed
            CHIPSET >= 340 {        ; IGP (Pentium IV northBridge)
                SETTINGS {
                    recommendDX = true
            }}
            CHIPSET >= ATI MOBILITY FIREGL V5 {
                SETTINGS {
                ; B.A. Rendering filled polys on OGL causes BSOD
                ; on T60P laptop with Mobility FireGL v5200
                ; (see bug #13601).
                Render/fillPolysEnable = false
                recommendDX = true
            }}
            CHIPSET >= MOBILITY FireGL V3200 {
                DRIVER = 00006.00014.00010.06497 {
                    SETTINGS {
                        ; These drivers have a hard time with shaders.
                        recommendDX = true
                        WaterSurface/waterSurfaceUsingShaders = false
                        Precipitation/usePrecipitationShader = false
                        SpeedTree/useBillboardsOnly = true
                        Terrain/fadeTextureLod = false
            }}}
            CHIPSET >= RAGE 128 {   ; {Pro,M3,A21}
                SETTINGS {
                    enableMipmaps = false
                    recommendDX = true
            }}
            CHIPSET >= FireMV 2400 {
                SETTINGS {
                    ; B.A. 5/4/09 - Old ATI drivers crash when using VBOs on these cards.
                    enableVertexBufferObjects = false
            }}
            CHIPSET >= MOBILITY MOBILITY FIRE GL 7800 {
                SETTINGS {
                    ; B.A. 5/4/09 - Old ATI drivers crash when using VBOs on these cards.
                    enableVertexBufferObjects = false
            }}
            CHIPSET >= ATI MOBILITY RADEON XPRESS { ; Radeon xpress series
                SETTINGS {
                    ; B.A. 5/4/09 - Old ATI drivers crash when using VBOs on these cards.
                    enableVertexBufferObjects = false
            }}
            CHIPSET >= MOBILITY RADEON Xpress { ; Radeon xpress series
                SETTINGS {
                    ; B.A. 5/4/09 - Old ATI drivers crash when using VBOs on these cards.
                    enableVertexBufferObjects = false
            }}
            CHIPSET >= MOBILITY RADEON 7500 {
                SETTINGS {
                    ; B.A. 5/4/09 - Old ATI drivers crash when using VBOs on these cards.
                    enableVertexBufferObjects = false
            }}
            CHIPSET >= MOBILITY RADEON 9 { ; Radeon 9xxx series
                SETTINGS {
                    ; B.A. 5/4/09 - Old ATI drivers crash when using VBOs on these cards.
                    enableVertexBufferObjects = false
            }}
            CHIPSET >= MOBILITY/RADEON 9 { ; Radeon 9xxx series
                SETTINGS {
                    ; B.A. 5/4/09 - Old ATI drivers crash when using VBOs on these cards.
                    enableVertexBufferObjects = false
            }}


            ;
            ; fifth generation
            ;
            CHIPSET >= RAGE Pro {
                SETTINGS {
                    ; imported from 3.0: disable feature for this chipset only,
                    ; instead of all ATI cards as was done before
                    disableVertexArrays = true

                    enableMipmaps = false
                    forceDX = true
            }}
            CHIPSET >= XPERT {      ; {98, 99, @PLAY, @WORK, LCD, XL} (8MB, XL is 4MB)
                                    ; also XPERT 2000 & XPERT 2000 Pro
                SETTINGS {
                    ; B.B. 7/22/05 - just a reminder of the setting
                    Render/detailAreaMax = 256

                    cantrun = true
            }}
            CHIPSET >= XPERT 128 {
                SETTINGS {
                    ; imported from 3.0: disable feature for this chipset only,
                    ; instead of all ATI cards as was done before
                    disableVertexArrays = true

                    enableMipmaps = false
                    forceDX = true
                    cantrun = false
            }}
            CHIPSET >= Rage Mobility { ; (8MB)
                SETTINGS {
                    cantRun = true
            }}
            CHIPSET >= Radeon 7 {   ; 7xxx series (7000:32MB, 7200:)
                SETTINGS {
                    ; B.B. 7/7/05 - need glBlend crash fix in Alchemy
                    recommendDX = true
                    Render/fillPolysEnable = false
                    ; B.A. 5/4/09 - Old ATI drivers crash when using VBOs on this card.
                    enableVertexBufferObjects = false
            }}
            CHIPSET >= RADEON XPRESS {   ; Xpress series (200, 1250, ...)
                SETTINGS {
                    ; B.A. 5/4/09 - Old ATI drivers crash when using VBOs on these cards.
                    enableVertexBufferObjects = false
            }}
            CHIPSET >= ATI RADEON XPRESS {   ; Xpress series (200, 1250, ...)
                SETTINGS {
                    ; B.A. 5/4/09 - Old ATI drivers crash when using VBOs on these cards.
                    enableVertexBufferObjects = false
            }}
            CHIPSET >= RADEON X300 {   ; RADEON X300 Series
                SETTINGS {
                    ; B.A. 5/4/09 - Crash when using VBOs to render filled polygons.
                    enableVertexBufferObjects = false
            }}
            CHIPSET >= RADEON X550 {   ; RADEON X550 Series
                SETTINGS {
                    ; B.A. 5/4/09 - Crash when using VBOs to render filled polygons.
                    enableVertexBufferObjects = false
            }}
            CHIPSET >= RADEON X600 {   ; RADEON X600 Series
                SETTINGS {
                    ; B.A. 5/4/09 - Crash when using VBOs to render filled polygons.
                    enableVertexBufferObjects = false
            }}
            CHIPSET >= ATI RADEON X1200 {   ; Xpress 1200
                SETTINGS {
                    ; B.A. 5/4/09 - Old ATI drivers crash when using VBOs on these cards.
                    enableVertexBufferObjects = false
            }}
            CHIPSET >= ATI RADEON X1250 {   ; Xpress 1250
                SETTINGS {
                    ; B.A. 5/4/09 - Old ATI drivers crash when using VBOs on these cards.
                    enableVertexBufferObjects = false
            }}
            CHIPSET >= ATI RADEON X1270 {   ; Xpress 1270
                SETTINGS {
                    ; B.A. 5/4/09 - Old ATI drivers crash when using VBOs on these cards.
                    enableVertexBufferObjects = false
            }}
            CHIPSET >= RADEON XPRESS 200 {   ; Integrated chipset
                SETTINGS {
                    WaterSurface/waterSurfaceUsingShaders = false
                    Precipitation/usePrecipitationShader = false
                    SpeedTree/useBillboardsOnly = true
                    Terrain/fadeTextureLod = false
            }}
            CHIPSET >= RADEON 8500 {
                SETTINGS {
                    ; B.A. 5/4/09 - Old ATI drivers crash when using VBOs on these cards.
                    enableVertexBufferObjects = false
            }}
            CHIPSET >= RADEON 9 {   ; 9000, 9100, 9200, 9250, 9600, 9700, 9800
                SETTINGS {
                    ; B.A. 5/4/09 - Old ATI drivers crash when using VBOs on these cards.
                    enableVertexBufferObjects = false
            }}
            CHIPSET >= RADEON 9200 {   ; 9200
                SETTINGS {
                    WaterSurface/waterSurfaceUsingShaders = false
                    Precipitation/usePrecipitationShader = false
                    SpeedTree/useBillboardsOnly = true
                    Terrain/fadeTextureLod = false
            }}
        }



        VENDOR >= Intel {
            SETTINGS {
                manufacturerUrl       = www.intel.com
                manufacturerDriverUrl = support.intel.com/support/graphics
                enableMipmaps = true
                ; DX mode has fewer problems on Intel cards than OGL mode.
                recommendDX = true
            }

            ; NOTE: PLATFORM_VERSION is checked using a string compare (as
            ; opposed to a numerical compare).  The >= operator checks that
            ; the version string begins with "2.".  Cards with OGL 1.X
            ; are already handled above.
            PLATFORM_VERSION >= 2. {
                ; B.A. - 9/19/12 (bug #7045999)
                ; Several older Intel cards expose a buggy version of OGL 2.X
                ; which causes crashes in GE.  This setting will force all of
                ; those older cards into the DX path.  The newer cards
                ; (e.g. Intel HD) expose OGL 3.0 or higher, so they shouldn't
                ; fall into this path.
                SETTINGS {
                    forceDX = true
            }}

            CHIPSET >=  Intel(R) HD { ; All HD Graphics chipsets are fairly new
                SETTINGS {
            }}
        }



        VENDOR >= Matrox {
            SETTINGS {
                manufacturerUrl       = www.matrox.com
                manufacturerDriverUrl = www.matrox.com/mga/support/drivers/latest/home.cfm

                ; Apparently, Matrox cards don't like vertex arrays
                ; 3.0: vertex arrays only disabled on G400 cards, not G200
                disableVertexArrays = true

                ; B.B. - 7/19/04, Matrox G450
                ; G400/G450: copying backbuffer takes ~500ms for 1k by 1k
                Render/fillPolysMaxTex = 512

                ; B.B. - 9/21/04, Matrox G450
                ; G450HD: driver clamps 2k by 256 textures halfway
                Render/forceSquareTextures = true

                ; B.B. - 7/1/2005
                ; based on BA's advice on Matrox's historical OpenGL drivers
                recommendDX = true
            }

            CHIPSET >= Matrox G550 { ; G.K. - 6/03/06 - G550 reports itself as G400
            SETTINGS {
            }}
            CHIPSET >= Matrox G450 { ; G450HD reports itself as a G400 card
                SETTINGS {
            }}
            CHIPSET >= Matrox G400 {
                SETTINGS {
                    ; G.K. - 6/03/06 - G450 and above report as G400
                    forceDX = true
            }}
            CHIPSET >= Matrox G200 {
            }
            CHIPSET >= Parhelia {   ; 512 (128MB)
                SETTINGS {
                    enableMipMaps = false
                    disableAnisotropicFiltering = true
                    Render/fillPolysEnable = false
            }}
        }



        ;
        ; Detection of non HW accelerated OGL cards
        ;
        VENDOR >= Microsoft {
            SETTINGS {
                ; B.B. 8/19/04
                ; note this means a software renderer is being used, it's not a Keyhole setting
                OGLsoftwareEmulated = true

                ; B.B. 3/30/05
                ; fill polys disable anyway, no chance for anisotropic filtering
                disableAnisotropicFiltering = true
                Render/fillPolysEnable = false
                WaterSurface/waterSurfaceUsingShaders = false
                Precipitation/usePrecipitationShader = false
                SpeedTree/useBillboardsOnly = true
                Terrain/fadeTextureLod = false
            }
        }



        VENDOR >= NVIDIA {
            SETTINGS {
                manufacturerUrl       = www.nvidia.com
                manufacturerDriverUrl = www.nvidia.com/content/drivers/drivers.asp

                ; enable mipmaps on nVidia cards
                enableMipmaps = true
            }
            ; nVidia's OGL 2.x cards seem to run OK in OGL mode.
            PLATFORM_VERSION >= 2. {
                SETTINGS {
                    recommendDX = false
                }
            }
            CHIPSET >= GeForce 256 {
                SETTINGS {
                    ; B.B. - 10/8/04
                    ; 2kx2k and higher textures fail in OGL
                    Render/maxTextureSize = 1024

                    ; B.B. - 4/6/2005, on the basis of DX performance
                    Render/fillPolysEnable = true
                    Render/fillPolysMaxTex = 512

                    ; B.A. - 4/1/09 - bug #1749137
                    enableVertexBufferObjects = false
            }}
            CHIPSET >= RIVA TNT {
                SETTINGS {
                    ; D.K. - 6/13/2001
                    ; disable mipmaps for lower-end TNT cards
                    enableMipmaps = false

                    ; B.B. - 4/7/2005, on the basis of GeForce 256
                    Render/maxTextureSize = 1024
                    Render/fillPolysEnable = true
                    Render/fillPolysMaxTex = 512

                    ; A.P. - 6/6/06, fix for artifacts
                    Render/detailAreaMax = 256
                    Render/maxTextureSize = 512

                    ; B.A. - 4/1/09 - bug #1749137
                    enableVertexBufferObjects = false
            }}
            CHIPSET >= GeForce2 {
                SETTINGS {
                    ; B.A. - 4/1/09 - bug #1749137
                    enableVertexBufferObjects = false
            }}
            CHIPSET >= GeForce3 {
                SETTINGS {
                    ; B.A. - 4/1/09 - bug #1749137
                    enableVertexBufferObjects = false
            }}
            CHIPSET >= GeForce4 {
                SETTINGS {
                    ; B.A. - 4/1/09 - bug #1749137
                    enableVertexBufferObjects = false
            }}
            CHIPSET >= GeForce4 420 Go {   ; (16MB)
                DRIVER = 00006.00013.00010.02846 {
                    SETTINGS {
                        ; B.B. - 7/8/05
                        ; laptop forced to use old driver from laptop manufacturer
                        ; problem may still exist on other driver versions
                        Render/fillPolysEnable = false
                        recommendDX = true
            }}}
            CHIPSET >= GeForce FX 5200 {
                SETTINGS {
                  WaterSurface/waterSurfaceUsingShaders = false
                  Precipitation/usePrecipitationShader = false
                  SpeedTree/useBillboardsOnly = true
                  Terrain/fadeTextureLod = false
            }}
            CHIPSET >= GeForce FX Go5200 {
                SETTINGS {
                  WaterSurface/waterSurfaceUsingShaders = false
                  Precipitation/usePrecipitationShader = false
                  SpeedTree/useBillboardsOnly = true
                  Terrain/fadeTextureLod = false
            }}
            CHIPSET >= GeForce 6100 {
                SETTINGS {
                  WaterSurface/waterSurfaceUsingShaders = false
                  Precipitation/usePrecipitationShader = false
                  SpeedTree/useBillboardsOnly = true
                  Terrain/fadeTextureLod = false
            }}
            CHIPSET >= GeForce FX 5700 {
                SETTINGS {
                  WaterSurface/waterSurfaceUsingShaders = false
                  Precipitation/usePrecipitationShader = false
                  SpeedTree/useBillboardsOnly = true
                  Terrain/fadeTextureLod = false
            }}
            CHIPSET >= Quadro FX 500 {
                SETTINGS {
                  WaterSurface/waterSurfaceUsingShaders = false
                  Precipitation/usePrecipitationShader = false
                  SpeedTree/useBillboardsOnly = true
                  Terrain/fadeTextureLod = false
            }}
            CHIPSET >= Quadro FX Go1000 {
                SETTINGS {
                  WaterSurface/waterSurfaceUsingShaders = false
                  Precipitation/usePrecipitationShader = false
                  SpeedTree/useBillboardsOnly = true
                  Terrain/fadeTextureLod = false
            }}
            CHIPSET >= Quadro FX 1100 {
                SETTINGS {
                  WaterSurface/waterSurfaceUsingShaders = false
                  Precipitation/usePrecipitationShader = false
                  SpeedTree/useBillboardsOnly = true
                  Terrain/fadeTextureLod = false
            }}
            CHIPSET >= GeForce 6150 {
                SETTINGS {
                  WaterSurface/waterSurfaceUsingShaders = false
                  Precipitation/usePrecipitationShader = false
                  SpeedTree/useBillboardsOnly = true
                  Terrain/fadeTextureLod = false
            }}
            CHIPSET >= Quadro NVS 280 PCI-E {   ; (64MB)
                SETTINGS {
                    ; B.B. - 4/29/05
                    ; 4k by 4k textures thrashes VRAM (.35fps), ok with 4kx4k b&w
                    Render/maxTextureSize = 2048
                    WaterSurface/waterSurfaceUsingShaders = false
                    Precipitation/usePrecipitationShader = false
                    SpeedTree/useBillboardsOnly = true
                    Terrain/fadeTextureLod = false
            }}
        }



        VENDOR >= S3 {
            SETTINGS {
                manufacturerUrl       = www.s3graphics.com
                manufacturerDriverUrl = www.s3graphics.com/drivers.jsp

                ; ** not mentioned in 3.0 - inherit defaults **
                ; The S3 chips do not support vertex arrays.
                disableVertexArrays = true

                ; B.B. - 9/24/04, ProSavage, SuperSavage IXC
                ; card clamps to the average of the outermost two pixels
                ; when s > 1 or t > 1, clamp to 1 pixel for s < 0, t < 0
                Render/olay2EdgeTransparency = true

                ; B.B. - 9/27/04, ProSavage, SuperSavage IXC
                ; rec DX because of missing atmosphere and busted fill polys even if it's slightly
                ; lower performance. Also with OGL it gets slower the more you use the app.
                recommendDX = true

                ; B.B. - 9/30/04, ProSavage, SuperSavage IXC
                ; borders are frequently obscured by terrain for distant earth
                Render/distantDrawOffsetScale = 0.3
            }

            CHIPSET >= VIA/S3G UniChrome IGP {
                SETTINGS {
                    ; JH - 6/06/06 - VIA/S3G cards crash at startup
                    forceDX = true
            }}
            CHIPSET >= Savage2000 {
                SETTINGS {
                    cantTexSubImage = true
            }}
            CHIPSET >= ProSavage {
                SETTINGS {
                    ; B.B. - 10/5/04
                    ; reduces client to 1fps, fixes atmosphere when visible
                    Render/fillPolysMaxTex = 256

                    ; B.B. - 10/5/04
                    ; fill polys include scattered vertical gaps
                    Render/fillPolysEnable = true
            }}
            CHIPSET >= SuperSavage {    ; IXC (laptop), IX, w/MV
                SETTINGS {
                    ; B.B. - 10/4/04, IXC
                    ; missing atmosphere

                    ; B.B. - 10/5/04, IXC
                    ; reduces client to 1fps, fixes atmosphere when visible
                    Render/fillPolysMaxTex = 256

                    ; B.B. - 10/5/04, IXC
                    ; fill polys include scattered transparent vertical lines
                    Render/fillPolysEnable = false
            }}
        }



        VENDOR >= SIS {
            SETTINGS {
                ; B.B. 4/7/05
                manufacturerUrl       = www.sis.com
                manufacturerDriverUrl = www.sis.com/support/support_prodid.htm

                ; ** not mentioned in 3.0 - inherit defaults **
                ; B.B. - 6/24/04, ProSavage DDR
                ; forceSquareTextures not required

                ; OGL drivers do not edge_clamp textures, may crash
                forceDX = true
            }
        }



        VENDOR >= Trident {
            CHIPSET >= Trident Video Accelerator Blade 3D {
                SETTINGS {
                    ; B.B. - 10/3/05
                    ; bbs users reported green screens in OGL
                    recommendDX = true
            }}
        }



        VENDOR >= XGI {
            CHIPSET >= XGI Volari {   ; XGI V3XT
                SETTINGS {
                    ; A.P. - 6/12/06
                    ; Clamp Filled polygons are broken in OGL.  When enabled,
                    ; they fill the 3dview completely with a solid color, which
                    ; does NOT go away even when the polygon is disabled. Only
                    ; by restarting the client will the issue clear up. Same
                    ; thing happens in the 3.0 client as well.  Suggested fix
                    ; is to recommend DirectX, in which polygons seem to work fine.
                    recommendDX = true
            }}
        }
    } ; END of OpenGL

    ;=============================================================================
    ; OPENGL ES 2.0
    ;=============================================================================
    PLATFORM = ogles20 {
        SETTINGS {
            ; Turn on VBO support for OGL.
            enableVertexBufferObjects = true
            ; Only use VBOs for some of the vertex arrays.
            geometryUsesVBOByDefault = false

            enableMipmaps = true
        }

        GFX_CAPABILITY(IG_GFX_CAPABILITY_GL2_SHADERS_SUPPORTED) = 0 {
          SETTINGS {
            cantRun = true
            recommendOGL = true
          }
        }

        ; GeForce 6xxx and 7xxx cards with older drivers (prior to 300 series)
        ; crash when a vertex buffer uses a stride of zero.
        ; allShaderAttrsRequired tells Alchemy to allocate colors, normals, and
        ; at least one set of UVs for every vertex.  This avoids the case where
        ; ANGLE uses zero-stride vertex buffers to handle missing vertex
        ; components.
        ; Terrain/alwaysComputeNormals is needed to force GE to fill in values
        ; for the normals, even when sun mode is off (by default, normals are
        ; only calculated when sun mode is on and the vertices don't already
        ; contain normals).
        ; (see bug #7883959)
        CHIPSET >= ANGLE (NVIDIA GeForce 6800 { SETTINGS {
            allShaderAttrsRequired = true
            Terrain/alwaysComputeNormals = true
        }}
        CHIPSET >= ANGLE (NVIDIA Quadro FX 3400 { SETTINGS {
            allShaderAttrsRequired = true
            Terrain/alwaysComputeNormals = true
        }}
        CHIPSET >= ANGLE (NVIDIA Quadro FX 4000 { SETTINGS {
            allShaderAttrsRequired = true
            Terrain/alwaysComputeNormals = true
        }}
        CHIPSET >= ANGLE (NVIDIA GeForce 7800 { SETTINGS {
            allShaderAttrsRequired = true
            Terrain/alwaysComputeNormals = true
        }}
        CHIPSET >= ANGLE (NVIDIA Quadro FX 4500 { SETTINGS {
            allShaderAttrsRequired = true
            Terrain/alwaysComputeNormals = true
        }}
        CHIPSET >= ANGLE (NVIDIA Quadro FX 3450 { SETTINGS {
            allShaderAttrsRequired = true
            Terrain/alwaysComputeNormals = true
        }}
        CHIPSET >= ANGLE (NVIDIA Quadro FX 1400 { SETTINGS {
            allShaderAttrsRequired = true
            Terrain/alwaysComputeNormals = true
        }}
        CHIPSET >= ANGLE (NVIDIA GeForce 6600 { SETTINGS {
            allShaderAttrsRequired = true
            Terrain/alwaysComputeNormals = true
        }}
        CHIPSET >= ANGLE (NVIDIA GeForce 6200 { SETTINGS {
            allShaderAttrsRequired = true
            Terrain/alwaysComputeNormals = true
        }}
        CHIPSET >= ANGLE (NVIDIA GeForce 6610 { SETTINGS {
            allShaderAttrsRequired = true
            Terrain/alwaysComputeNormals = true
        }}
        CHIPSET >= ANGLE (NVIDIA GeForce 6700 { SETTINGS {
            allShaderAttrsRequired = true
            Terrain/alwaysComputeNormals = true
        }}
        CHIPSET >= ANGLE (NVIDIA Quadro NVS 440 { SETTINGS {
            allShaderAttrsRequired = true
            Terrain/alwaysComputeNormals = true
        }}
        CHIPSET >= ANGLE (NVIDIA Quadro NVS 285 { SETTINGS {
            allShaderAttrsRequired = true
            Terrain/alwaysComputeNormals = true
        }}
        CHIPSET >= ANGLE (NVIDIA Quadro NVS 440 { SETTINGS {
            allShaderAttrsRequired = true
            Terrain/alwaysComputeNormals = true
        }}
        CHIPSET >= ANGLE (NVIDIA Quadro NVS 120 { SETTINGS {
            allShaderAttrsRequired = true
            Terrain/alwaysComputeNormals = true
        }}
        CHIPSET >= ANGLE (NVIDIA Quadro FX 540 { SETTINGS {
            allShaderAttrsRequired = true
            Terrain/alwaysComputeNormals = true
        }}
        CHIPSET >= ANGLE (NVIDIA Quadro FX 550 { SETTINGS {
            allShaderAttrsRequired = true
            Terrain/alwaysComputeNormals = true
        }}
        CHIPSET >= ANGLE (NVIDIA GeForce 6500 { SETTINGS {
            allShaderAttrsRequired = true
            Terrain/alwaysComputeNormals = true
        }}
        CHIPSET >= ANGLE (NVIDIA GeForce 6250 { SETTINGS {
            allShaderAttrsRequired = true
            Terrain/alwaysComputeNormals = true
        }}
        CHIPSET >= ANGLE (NVIDIA GeForce 7100 { SETTINGS {
            allShaderAttrsRequired = true
            Terrain/alwaysComputeNormals = true
        }}
        CHIPSET >= ANGLE (NVIDIA GeForce 7500 { SETTINGS {
            allShaderAttrsRequired = true
            Terrain/alwaysComputeNormals = true
        }}
        CHIPSET >= ANGLE (NVIDIA GeForce 7300 { SETTINGS {
            allShaderAttrsRequired = true
            Terrain/alwaysComputeNormals = true
        }}
        CHIPSET >= ANGLE (NVIDIA GeForce 7550 { SETTINGS {
            allShaderAttrsRequired = true
            Terrain/alwaysComputeNormals = true
        }}
        CHIPSET >= ANGLE (NVIDIA GeForce 7350 { SETTINGS {
            allShaderAttrsRequired = true
            Terrain/alwaysComputeNormals = true
        }}
        CHIPSET >= ANGLE (NVIDIA Quadro FX 350 { SETTINGS {
            allShaderAttrsRequired = true
            Terrain/alwaysComputeNormals = true
        }}
        CHIPSET >= ANGLE (NVIDIA GeForce 6150 { SETTINGS {
            allShaderAttrsRequired = true
            Terrain/alwaysComputeNormals = true
        }}
        CHIPSET >= ANGLE (NVIDIA GeForce 6100 { SETTINGS {
            allShaderAttrsRequired = true
            Terrain/alwaysComputeNormals = true
        }}
        CHIPSET >= ANGLE (NVIDIA GeForce 7900 { SETTINGS {
            allShaderAttrsRequired = true
            Terrain/alwaysComputeNormals = true
        }}
        CHIPSET >= ANGLE (NVIDIA GeForce 7950 { SETTINGS {
            allShaderAttrsRequired = true
            Terrain/alwaysComputeNormals = true
        }}
        CHIPSET >= ANGLE (NVIDIA GeForce 7600 { SETTINGS {
            allShaderAttrsRequired = true
            Terrain/alwaysComputeNormals = true
        }}
        CHIPSET >= ANGLE (NVIDIA GeForce 7650 { SETTINGS {
            allShaderAttrsRequired = true
            Terrain/alwaysComputeNormals = true
        }}
        CHIPSET >= ANGLE (NVIDIA Quadro FX 1500 { SETTINGS {
            allShaderAttrsRequired = true
            Terrain/alwaysComputeNormals = true
        }}
        CHIPSET >= ANGLE (NVIDIA Quadro FX 560 { SETTINGS {
            allShaderAttrsRequired = true
            Terrain/alwaysComputeNormals = true
        }}
        CHIPSET >= ANGLE (NVIDIA GeForce 7025 { SETTINGS {
            allShaderAttrsRequired = true
            Terrain/alwaysComputeNormals = true
        }}
        CHIPSET >= ANGLE (NVIDIA GeForce 7050 { SETTINGS {
            allShaderAttrsRequired = true
            Terrain/alwaysComputeNormals = true
        }}
        CHIPSET >= ANGLE (NVIDIA GeForce 7150 { SETTINGS {
            allShaderAttrsRequired = true
            Terrain/alwaysComputeNormals = true
        }}
    }

  ; G.V. - 4/3/07
  ; Switch to DX on startup for ATI cards running certain old drivers (6.14.10.6404 - 6.14.10.6483)
  ; as the client crashes for these configurations in OpenGL (see Bug 11866)
  ; Do this outside of "PLATFORM {..}" as PLATFORM has not been set yet
  VENDOR >= 00001002 { ; ATI

    DRIVER = 00006.00014.00010.06404 {
      SETTINGS {
        switchToDXOnStartup = true
      }
    }
    DRIVER = 00006.00014.00010.06414 {
      SETTINGS {
        switchToDXOnStartup = true
      }
    }
    DRIVER = 00006.00014.00010.06422 {
      SETTINGS {
        switchToDXOnStartup = true
      }
    }
    DRIVER = 00006.00014.00010.06430 {
      SETTINGS {
        switchToDXOnStartup = true
      }
    }
    DRIVER = 00006.00014.00010.06436 {
      SETTINGS {
        switchToDXOnStartup = true
      }
    }
    DRIVER = 00006.00014.00010.06444 {
      SETTINGS {
        switchToDXOnStartup = true
      }
    }
    DRIVER = 00006.00014.00010.06451 {
      SETTINGS {
        switchToDXOnStartup = true
      }
    }
    DRIVER = 00006.00014.00010.06458 {
      SETTINGS {
        switchToDXOnStartup = true
      }
    }
    DRIVER = 00006.00014.00010.06462 {
      SETTINGS {
        switchToDXOnStartup = true
      }
    }
    DRIVER = 00006.00014.00010.06467 {
      SETTINGS {
        switchToDXOnStartup = true
      }
    }
    DRIVER = 00006.00014.00010.06476 {
      SETTINGS {
        switchToDXOnStartup = true
      }
    }
    DRIVER = 00006.00014.00010.06483 {
      SETTINGS {
        switchToDXOnStartup = true
      }
    }
    ; B.A. 6/3/10
    ; The latest ATI drivers (10.5) cause BSOD on WinXP for X2 cards in OGL mode
    ; (bug #2732507).  These cards also have problems in OGL mode under
    ; Vista and Win7 (bug #2793850).
    CHIPSET >= 00009441 { ;ATI Radeon HD 4870 X2
        SETTINGS {
            forceDX = true
    }}
    CHIPSET >= 00009443 { ;ATI Radeon HD 4850 X2
        SETTINGS {
            forceDX = true
    }}
    CHIPSET >= 00009506 { ;ATI Mobility Radeon HD 3850 X2
        SETTINGS {
            forceDX = true
    }}
    CHIPSET >= 00009509 { ;ATI Mobility Radeon HD 3870 X2
        SETTINGS {
            forceDX = true
    }}
    CHIPSET >= 0000950F { ;ATI RADEON HD 3870 X2
        SETTINGS {
            forceDX = true
    }}
    CHIPSET >= 00009513 { ;ATI Radeon HD 3850 X2
        SETTINGS {
            forceDX = true
    }}
    CHIPSET >= 0000958A { ;ATI Radeon HD 2600 X2 Series
        SETTINGS {
            forceDX = true
    }}
  } ; END ATI


  VENDOR >= 000010DE { ; nVidia
    CHIPSET >= 00000020 {   ; RIVA TNT
      ; B.B. - 4/17/2007
      ; crash viewing denver, works fine in DX
      SETTINGS {
        switchToDXOnStartup = true
      }
    }
  } ; END nVidia


} ; END of win_nt

