Texture Console

==Definitions==
Decode - Uncompressing a downloaded texture, in SL's case a JPEG2000 texture, into memory. Once it is decoded it will be handed to OpenGL.
Discard Level - A discard level of 0 means the highest available detail version of the texture. Discard level 1 means the second highest detail version, which is 1/2 the size in each dimension (and thus 1/4 the memory footprint in memory)
== 3.7.2 ==
Note: Unless the scene is *very* simple, this display only shows a tiny fraction of the number of textures. The textures displayed are active textures (i.e. textures that need more data) ordered by priority.
# Amount of texture data handed to OpenGL / Maximum amount SecondLife will hand to OpenGL*
# Amount of texture data currently bound by OpenGL / Threshold at which we decrease texture detail*
# FBO (Needs Details)
# Raw Tot. (ND)
# Bias. Texture detail multiplier. > 1 indicates that texture detail is being decreased to fit into memory
# Cache.
# Net Tot Tex. Total size of textures (MB) downloaded over network in this session. Includes both UDP and HTTP transport. Value is updated internally on a 10-second timer and so lags other activity in the console.
# Tot Obj. (MB) (ND)
# Tot Htp. Total number of HTTP requests issued for texture downloads. Repeated downloads (say, for existing or different discard levels) are counted individually. Retries on connection or HTTP failures were counted in the past. They are not counted currently.
# Cread. Count of on-disk texture cache reads requested by texture fetch code.
# Cwrite. Count of on-disk texture cache writes requested by texture fetch code.
# Rwait. Count of texture fetch requests that went to resource wait state (HTW) because the HTTP library had enough work queued up.
# Textures. Number of textures known to the texture management system. These will be in various states of completeness.
# Fetch. Number of outstanding texture fetch requests / Number of completed fetch requests awaiting finalization (leading to deletion of the request).
# Pkts. Count of UDP packets received containing texture header or image data. / Count of UDP packets received that could not be processed due to some error such as corruption or invalid ordering or no valid request.
# Cache R/W. Count of outstanding cache read requests / Count of outstanding cache write requests
# LFS. Count of async file operation requests outstanding on the LFS worker thread. LFS shouldn’t be involved in texture operations anymore so probably not interesting.
# RAW. Count of instances of LLImageRaw objects currently in the system.
# HTP. Count of active HTTP requests issued or queued for texture fetching. Completion will contribute to ‘Tot Htp’ above. These are the requests made available to the lower-level HTTP transport and not the number of concurrent requests (which is limited to eight by default).
# DEC. Count of requests outstanding for decoding of texture data.
# CRE. (ND)
# BW. UDP + HTTP texture bandwidth as consumed / UDP bandwidth limit as configured. Text will change color to yellow or red as configured value is approached and exceeded.
# Tex UUID. Fragment of UUID identifying texture. UUIDs will be rendered with varying colors:
#* White = Normal priority image
#* Yellow = Selected image, prioritized
#* Orange = Image under mouse ("hover"), prioritized
#* Magenta = Boosted (prioritized) image
#* Green = UI image 
#* Grey = Image not in state machine (hopefully because current discard <= desired discard)
# Area. Area on screen. Approximate # of pixels this texture covers on-screen.
# DDis(Req). Desired Discard Level (see Discard definition) which is a function of area on screen and importance / Requested Discard Level. This is the client's record of the last discard level requested to the server. This is usually the same as Desired Discard Level, but may be larger if we have stopped requesting the texture because it is out of view (no area) or we have all of its data.
# DecodePri(Fetch). Priority for decode of image / Priority as requested for fetching.
# Progress Bar. Fills up as the requested texture is downloaded. This is basically a download progress bar for the textures current Desired Discard Level (but will only fill up if the requested discard level is 0). Incremental progress is indicated for UDP requests, HTTP will jump to completion.
# pk/max. For UDP, number of packets received (reflected in progress bar) / Max number of packets
# State. The texture request's current state in the fetching/decoding state machine. States include:
#* "---" - The texture is not being fetched (hopefully because current discard <= desired discard). If red, invalid state.
#* "INI" - The texture is waiting to be processed by the state machine
#* "DSK" - Reading from local cache (cyan=header, blue=body) 
#* "NET" - Indicates the texture is in the UDP request queue, but has not yet been requested from the servers
#* "SIM" - Waiting for UDP packet data from simulator
#* "HTW" - Resource waiting for HTTP resources prior to "HTP" state
#* "REQ" - Preparing to send HTTP request to grid
#* "HTP" - Waiting for HTTP response data
#* "DEC" - Decoding Image
#* "WRT" - Writing image to local cache
#* "END" - Waiting for a request for more data or deletion (after timeout)
#* "CRE" - Texture needs to be created
#* "FUL/BAD/MIS" - Debug, shouldn't happen (needs create, fully loaded, bad, missing)
# Pkt. Handling information for recently-received data (mostly UDP-oriented):
#* White = packet received from simulator
#* Green = data requested from simulator
#* Yellow = texture processed by state machine
# Bnd. Binding of fetched data to OpenGL:
#* Purple = Texture is currently bound (i.e. being rendered)
# W x H. Dimensions of image.
# (Dis). Actual Discarded level. This should eventually (after textures are downloaded and decoded) be the same as Desired Discard Level (DDis).
# Mem. Amount of memory consumed by the texture.
# Mesh Reqs(Tot/Htp/Big). Mesh status line starting with counts of mesh requests issued: total (pre-cache), 'normal' HTTP and 'Big' (over 2MB) HTTP. A mesh request will typically be for a part of a full mesh: a single level-of-detail or perhaps a header. A request may be satisfied by the mesh cache. If not in the cache, then an HTTP request is issued. That request will be either a 'normal' or a 'big' request.
# Rtr/Err. Retries issued and final errors received for HTTP mesh requests.
# Cread/Cwrite. Mesh cache read and write operations. 'Cwrite' will approximately follow 'Htp' + 'Big'. 'Cread' gives an indication of the effectiveness of the local mesh cache.
# Low/At/High. The mesh fetching code maintains a pool of requests. This code attempts to keep the pool filled between the 'Low' and 'High' water levels shown here. The current pool level is given by 'At' and the pool is refilled when it falls below 'Low'.
Some patterns to look for when searching for texture fetch bugs:
1. If Cread is growing quickly while Cwrite and 'Tot Htp' are
static or growing slowly then the texture cache is populated
and being used.
2. If Cwrite and 'Tot Htp' grow at about the same rate as
Cread, then either the texture cache is cold or it isn't working.
3. If 'Tot Htp' is growing faster than 'Cwrite', then we're
doing unnecessary fetches for assets for some reason.
==Notes==
* 'Texture Memory' or 'OpenGL Memory' refers to data passed to the OpenGL drivers. Depending upon the graphics card and driver, this memory may be on the graphics card, in system memory, or (likely) both.