Return to glqwcl-readme.txt CVS log

Up to [Quake] / quakeworld / docs

Annotation of quakeworld/docs/glqwcl-readme.txt, revision 1.1

1.1     ! root        1: GLQWCL v2.20
        !             2: 
        !             3: 3dfx owners -- read the 3dfx.txt file.
        !             4: 
        !             5: On a standard OpenGL system, all you should need to do to run glqwcl is put 
        !             6: glqwcl.exe in your quake directory, and run it from there.  DO NOT install 
        !             7: the opengl32.dll unless you have a 3dfx!  Glquake should change the screen 
        !             8: resolution to 640*480*32k colors and run full screen by default.
        !             9: 
        !            10: If you are running win-95, your desktop must be set to 32k or 64k colors 
        !            11: before running glqwcl.  NT can switch automatically.
        !            12: 
        !            13: Theoretically, glqwcl will run on any compliant OpenGL that supports the 
        !            14: texture objects extensions, but unless it is very powerfull hardware that 
        !            15: accelerates everything needed, the game play will not be acceptable.  If it 
        !            16: has to go through any software emulation paths, the performance will likely 
        !            17: by well under one frame per second.
        !            18: 
        !            19: At this time (march '97), the only standard opengl hardware that can play 
        !            20: glqwcl reasonably is an intergraph realizm, which is a VERY expensive card.  
        !            21: 3dlabs has been improving their performance significantly, but with the 
        !            22: available drivers it still isn't good enough to play.  Some of the current 
        !            23: 3dlabs drivers for glint and permedia baords can also crash NT when exiting 
        !            24: from a full screen run, so I don't recommend running glqwcl on 3dlabs 
        !            25: hardware.
        !            26: 
        !            27: 3dfx has provided an opengl32.dll that implements everything glqwcl needs, 
        !            28: but it is not a full opengl implementation.  Other opengl applications are 
        !            29: very unlikely to work with it, so consider it basically a "glqwcl driver".  
        !            30: See the encluded 3dfx.txt for specific instalation notes.  3dfx can only run 
        !            31: full screen, but you must still have your desktop set to a 16 bit color mode 
        !            32: for glqwcl to start.
        !            33: 
        !            34: resolution options
        !            35: ------------------
        !            36: We had dynamic resolution changing in glqwcl for a while, but every single 
        !            37: opengl driver I tried it on messed up in one way or another, so it is now 
        !            38: limited to startup time only.
        !            39: 
        !            40: glqwcl -window
        !            41: This will start glqwcl in a window on your desktop instead of switching the 
        !            42: screen to lower resolution and covering everything.
        !            43: 
        !            44: glqwcl -width 800 -height 600
        !            45: Tries to run glqwcl at the specified resolution.  Combined with -window, it 
        !            46: creates a desktop window that size, otherwise it tries to set a full screen 
        !            47: resolution.
        !            48: 
        !            49: texture options
        !            50: ---------------
        !            51: The amount of textures used in the game can have a large impact on performance.  
        !            52: There are several options that let you trade off visual quality for better 
        !            53: performance.
        !            54: 
        !            55: There is no way to flush already loaded textures, so it is best to change 
        !            56: these options on the command line, or they will only take effect on some of 
        !            57: the textures when you change levels.
        !            58: 
        !            59: OpenGL only allows textures to repeat on power of two boundaries (32, 64, 
        !            60: 128, etc), but software quake had a number of textures that repeated at 24 
        !            61: or 96 pixel boundaries.  These need to be either stretched out to the next 
        !            62: higher size, or shrunk down to the next lower.  By default, they are filtered 
        !            63: down to the smaller size, but you can cause it to use the larger size if you 
        !            64: really want by using: 
        !            65: 
        !            66: glqwcl +gl_round_down 0
        !            67: This will generally run well on a normal 4 MB 3dfx card, but for other cards 
        !            68: that have either worse texture management or slower texture swapping speeds, 
        !            69: there are some additional settings that can drastically lower the amount of 
        !            70: textures to be managed.
        !            71: 
        !            72: glqwcl +gl_picmip 1
        !            73: This causes all textures to have one half the dimensions they otherwise would.  
        !            74: This makes them blurry, but very small.  You can set this to 2 to make the 
        !            75: textures one quarter the resolution on each axis for REALLY blurry textures.
        !            76: 
        !            77: glqwcl +gl_playermip 1
        !            78: This is similar to picmip, but is only used for other players in deathmatch.  
        !            79: Each player in a deathmatch requires an individual skin texture, so this can 
        !            80: be a serious problem for texture management.  It wouldn't be unreasonable to 
        !            81: set this to 2 or even 3 if you are playing competatively (and don't care if 
        !            82: the other guys have smudged skins).  If you change this during the game, it 
        !            83: will take effect as soon as a player changes their skin colors.
        !            84: 
        !            85: run time options
        !            86: ----------------
        !            87: At the console, you can set these values to effect drawing.
        !            88: 
        !            89: gl_texturemode GL_NEAREST
        !            90: Sets texture mapping to point sampled, which may be faster on some GL systems 
        !            91: (not on 3dfx).
        !            92: 
        !            93: gl_texturemode GL_LINEAR_MIPMAP
        !            94: This is the default texture mode.
        !            95: 
        !            96: gl_texturemode GL_LINEAR_MIPMAP_LINEAR
        !            97: This is the highest quality texture mapping (trilinear), but only very high 
        !            98: end hardware (intergraph intense 3D / realizm) supports it.  Not that big of 
        !            99: a deal, actually.
        !           100: 
        !           101: gl_finish 0
        !           102: This causes the game to not issue a glFinish() call each frame, which may make 
        !           103: some hardware run faster.  If this is cleared, the 3dfx will back up a number 
        !           104: of frames and not be very playable.
        !           105: 
        !           106: gl_flashblend 0
        !           107: By default, glqwcl just draws a shaded ball around objects that are emiting 
        !           108: light.  Clearing this variable will cause it to properly relight the world 
        !           109: like normal quake, but it can be a significant speed hit on some systems.
        !           110: 
        !           111: gl_ztrick 0
        !           112: Glquake uses a buffering method that avoids clearing the Z buffer, but some 
        !           113: hardware platforms don't like it.  If the status bar and console are flashing 
        !           114: every other frame, clear this variable.
        !           115: 
        !           116: gl_keeptjunctions 0
        !           117: If you clear this, glqwcl will remove colinear vertexes when it reloads the 
        !           118: level.  This can give a few percent speedup, but it can leave a couple stray 
        !           119: blinking pixels on the screen.
        !           120: 
        !           121: novelty features
        !           122: ----------------
        !           123: These are some rendering tricks that were easy to do in glqwcl.  They aren't 
        !           124: very robust, but they are pretty cool to look at.
        !           125: 
        !           126: r_shadows 1
        !           127: This causes every object to cast a shadow.
        !           128: 
        !           129: r_wateralpha 0.7
        !           130: This sets the opacity of water textures, so you can see through it in properly 
        !           131: processed maps.  0.3 is very faint, almost like fog.  1 is completely solid 
        !           132: (the default).  Unfortunately, the standard quake maps don't contain any 
        !           133: visibility information for seeing past water surfaces, so you can't just play 
        !           134: quake with this turned on.  If you just want to see what it looks like, you 
        !           135: can set "r_novis 1", but that will make things go very slow.  When I get a 
        !           136: chance, I will probably release some maps that have been processed properly 
        !           137: for this.
        !           138: 
        !           139: r_mirroralpha 0.3
        !           140: This changes one particular texture (the stained glass texture in the EASY 
        !           141: start hall) into a mirror.  The value is the opacity of the mirror surface.
        !           142: 
        !           143: 
        !           144: 

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.