Texture Audit

Intercept all of the textures on the sim by loading one of the following tools on your compter.

Move to the sim of interest.

Set your avatar not to timeout (advanced/character/character tests and disabling away timeout).

Set your avatar to return to the last position (Edit/Preferences/General and enable My Last Postion)

Cleare cache and log out.

Start the client intercept below.

Log back into SL and wait for 15 minutes.

Exit from SL and use a PC tool to evaluate the textures from the sim to identify any textures over 512x512.

Disable the client intercept, return to the sim and replace textures that are at over 512x512 unless absolutely necessary (hardly ever).

Texture Audit Tools: Windows

Download GLIntecept (Windows) here.

From: http://www.opengl.org/sdk/tools/GLIntercept/

GLIntercept

GLIntercept (http://glintercept.nutty.org) is a free and open-source OpenGL function call interceptor providing a replacement wrapper (opengl32.dll) that exports all OpenGL entry points. When an OpenGL call is made, the GLIntercept wrapper processes it before passing the call onto the real OpenGL system.

While there are many tools that provide similar functionality, mostly for logging purposes, GLIntercept provides an extensible plugin interface to allow custom logging or manipulation of the OpenGL state.

Feature List

GLIntercept is a OpenGL function call interceptor that can:

• Save all OpenGL function calls to text or XML format with the option to log individual frames. The XML log types include XSL formatting for viewing in web browsers that support it. (IE6+, FireFox, Mozilla 1.4+).
• Run time shader edit. Display shader usage and edit the shaders at run time. Supports ARB VP/FP/GLSL and NV VP/FP.
• Free camera. Fly around the geometry sent to the graphics card and enable/disable wireframe/backface-culling/view frustum render.
• Save and track textures. (1D,2D,3D,NVRect and p-buffer/FBO bound textures are supported.) Saving can be to TGA,PNG and JPG formats.
• Save and track shaders/programs. ARB VP/FP/GLSL and NV VP/FP are supported.
• Save and track display lists.
• Saving of the OpenGL frame buffer (color/depth/stencil) pre and post render calls. The ability to save the "diff" of pre and post images is also available.
• Track error states (logging them to the debugger output) and breaking on errors.
• Basic thread error checking.
• Function timer log.
• Resource leak tracking for contexts, display lists, shaders and textures.
• OpenGL extension/version override. Add/remove/replace the OpenGL extension and version strings. (Test lower end rendering paths without changing cards)
• Function call stats. Provide a summary of what OpenGL functions are called and how often they are called.

While this tool is designed to aid programmers debug OpenGL applications, it can also be used to grab the textures and models (via the OGLE plugin) used in OpenGL applications. Please respect copyright and authors' wishes if you do this.

Then from http://oreilly.com/pub/h/5235

Snagging Textures with GLIntercept
If you want to grab textures out of Second Life to see how people have made those neat trees, the stunning clothes, or maybe an old texture you lost, GLIntercept is the tool for the job.

Contributed by: andrewburton
[01/26/06 | Discuss (34) | Link to this hack]

If you want to grab textures out of Second Life to see how people have made those neat trees, the stunning clothes, or maybe an old texture you lost, GLIntercept is the tool for the job. GLIntercept is a program that grabs OpenGL information directly from memory. It does a lot more than just capturing textures; with it you can extract prim information, avatars, and textures. This information can be exported into other 3D programs, such as Maya. This hack, however, is just about the images.

To get started, you'll first need to download GLIntercept (http://glintercept.nutty.org/download.html) from its website. They have several versions, but if you're mostly interested in grabbing textures, just grab the latest Binary for Windows.

Once it's downloaded, run the installation program [Ed. As administrator]. A standard installation will put the files on your C: drive, in the C:\Program Files\GLIntercept0_5 directory -- "0_5" will likely vary depending on the version you download. There is no executable GLIntercept program, so don't worry because you can't find an *.exe file.

Next, copy the files opengl32.dll and gliConfig.ini from the GLIntercept directory into your Second Life directory (for example: C:\Program Files\SecondLife). Once those files are copied, run the SecondLife.exe program; use it for a few minutes, then log out.

NOTE: Second Life will operate a good bit slower with GLIntercept. You may want to log in a head of time, get where you want to grab textures, and then log out.

There will be two new files and three new folders in your Second Life Directory. The folder named Images is what you want. Within Images will be several hundred, maybe several thousand, JPG and PNG files. These are all the textures that your Second Life rendered on screen while you were logged in.

NOTE: Second Life images appear to load in stages. To get a full texture, you need to wait until a prim and its texture(s) have fully loaded before moving off or logging out. Otherwise all you may get of a 512x512 texture is a smaller, 128x128 version.

Texture Audit Tools: Linux

About BuGLe

BuGLe is a tool for OpenGL debugging, implemented as a wrapper library that sits between your program and OpenGL. While still in development, it can already do the following:

• Dump a textual log of all GL calls made.
• Take a screenshot or capture a video.
• Call glGetError after each call to check for errors, and wrap glGetError so that this checking is transparent to your program.
• Capture and display statistics (such as frame rate)
• Force a wireframe mode
• Recover a backtrace from segmentation faults inside the driver, even if the driver is compiled without symbols.

In addition, there is a debugger (gldb) that lets you set breakpoints and examine backtraces. It also lets you examine OpenGL state, enable and disable filters, and drop into gdb to see what is going wrong. A GUI version of the debugger (gldb-gui) is currently in development, and a preliminary version is available with the latest releases. It features a texture viewer and a shader viewer.

You can download the source from the project page, or view the documentation online. BuGLe is also available in Gentoo portage and the BSD ports collection.

Requirements

• GCC 3.2 or later (4.0 is broken, but 4.1 works).
• FFmpeg is needed for video capture
• GNU readline is recommended for history editing in gldb
• GTK+ is required for gldb-gui
• GtkGLExt is highly recommended for gldb-gui (without it, the texture display will not work)

Example

Here is an extract from a log, generated from an application I am writing. Note that GLenums are displayed by name, and pointers are followed to the correct number of elements.

stats.fps: 22.671
stats.fragments: 52335
stats.triangles: 99732
trace.call: glXSwapBuffers(0x8117720, 0x01c00021)
trace.call: glXMakeCurrent(0x8117720, 0x01c00021, 0x8444800) = 1
trace.call: glBindBufferARB(GL_ARRAY_BUFFER, 1)
trace.call: glMapBufferARB(GL_ARRAY_BUFFER, GL_READ_WRITE) = 0x45c3c000
trace.call: glUnmapBufferARB(GL_ARRAY_BUFFER) = GL_TRUE
trace.call: glBindBufferARB(GL_ARRAY_BUFFER, 0)
trace.call: glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
trace.call: glLoadMatrixd(0xbfffe610 -> { { 0, -0.29661, 1.22295, 0 }, { 1.22295, 0, 0, 0 }, { 0, 1.18644, 0.305739, 0 }, { 0.037888, 1.61781, -1.52576, 1 } })
trace.call: glActiveTextureARB(GL_TEXTURE0)
trace.call: glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, 0xbfffe5d0 -> { 0.778524, 0.778524, 0.569631, 0 })
trace.call: glGetIntegerv(GL_MAX_TEXTURE_UNITS, 0xbfffe688 -> 4)
trace.call: glBindBufferARB(GL_ARRAY_BUFFER, 1)
trace.call: glVertexPointer(3, GL_FLOAT, 32, (nil))

Texture Audit Tools: Mac

OpenGL Profiler is the Apple developed, best of class, tool to assist developers in debugging and optimizing their OpenGL usage. The following gives and overview of some of the tools the OpenGL Profiler provides which allow developers to investigate all aspects of an OpenGL client application.

Main Window

The Profiler main panel controls tracing, collection of resources (textures and programs) and statistics. It is also a convenient place to view a client’s frame rate.

See more at: http://developer.apple.com/graphicsimaging/opengl/profiler_image.html