On Thu, Jul 01, 2004 at 12:51:23PM +0900, Sasayama wrote:
| Two more questions. First, is it clear on what is covered by each test
| of glean?
Each test includes a description of what it's intended to do. Those are
fairly detailed for some tests, but not for others; it depends on what
the author of the test decided to write. I've appended a log of a glean
run with the "verbose" option enabled, which includes all the
descriptive text.
| Second, is it easy to examine the output correctness of each test in
| glean? It is very nice if it could make a summary report automatically.
Glean produces a summary, but I'd be the first to admit that it needs to
be more readable. The intent is that you should be able to grep the
summary for the word "FAIL" to find any failures.
Glean also has the ability to compare the results of two runs, so if
you're developing an OpenGL implementation you can see if a change has
fixed an old problem or introduced a new one.
I think you'll find that the tests in glean don't cover everything you
need, but it may be helpful as part of whatever testing system you
finally decide to use. And of course, if you want to contribute tests,
that would be much appreciated by everyone.
Allen
Following is the output from a "verbose" run:
----------------------------------------------------------------------
This trivial test simply verifies the internal support for basic
tests. It is run on every OpenGL-capable drawing surface
configuration that supports creation of a window.
basic: PASS rgba8, db, z24, s8, accrgba16, win+pmap, id 35
----------------------------------------------------------------------
This trivial test simply verifies the internal support for basic
performance tests. It is run on every OpenGL-capable drawing surface
configuration that supports creation of a window. If everything is
working correctly, each result should be close to 0.1 second.
basicPerf: PASS rgba8, db, z24, s8, accrgba16, win+pmap, id 35
Average = 0.108445 Range = [0.107296, 0.109713]
----------------------------------------------------------------------
This test sanity-checks the ability to use multiple rendering
contexts. It creates several contexts with differing
characteristics (e.g., some are direct-rendering and some
are indirect-rendering, if the window system binding supports
that distinction). Then it runs through all pairs of contexts,
making each one "current" in turn and verifying that simple
rendering succeeds.
makeCurrent: PASS rgba8, db, z24, s8, accrgba16, win+pmap, id 35
----------------------------------------------------------------------
This test checks all combinations of source and destination
blend factors for the GL_FUNC_ADD blend equation. It operates
on all RGB or RGBA drawing surface configurations that support
the creation of windows.
Note that a common cause of failures for this test is small errors
introduced when an implementation scales color values incorrectly;
for example, converting an 8-bit color value to float by
dividing by 256 rather than 255, or computing a blending result
by shifting a double-width intermediate value rather than scaling
it. Also, please note that the OpenGL spec requires that when
converting from floating-point colors to integer form, the result
must be rounded to the nearest integer, not truncated.
[1.2.1, 2.13.9]
The test reports two error measurements. The first (readback) is
the error detected when reading back raw values that were written
to the framebuffer. The error in this case should be very close
to zero, since the values are carefully constructed so that they
can be represented accurately in the framebuffer. The second
(blending) is the error detected in the result of the blending
computation. For the test to pass, these errors must both be
no greater than one least-significant bit in the framebuffer
representation of a color.
blendFunc: PASS rgba8, db, z24, s8, accrgba16, win+pmap, id 35
----------------------------------------------------------------------
This test makes a rough estimate of the cost of a glBindTexture()
operation, expressed in microseconds.
Since the apparent cost of a texture bind is dependent on many
factors (including the fraction of the texture map that's actually
used for drawing, on machines that cache textures; texture map
size; texel format; etc.), a general-purpose test can only estimate
it. In this test we do so by drawing random triangles of very
small size, and reporting simple statistics concerning the cost.
texBindPerf: PASS rgba8, db, z24, s8, accrgba16, win+pmap, id 35
Approximate texture binding time = 3.59312 microseconds.
Range of valid measurements = [3.56699, 3.62002]
----------------------------------------------------------------------
This test checks the contents of the strings returned by
glGetString(): the vendor name, renderer name, version, and
extensions. It is run on every OpenGL-capable drawing surface
configuration that supports creation of a window.
getString: PASS rgba8, db, z24, s8, accrgba16, win+pmap, id 35
vendor: NVIDIA Corporation
renderer: GeForce4 Ti 4200/AGP/SSE2
version: 1.4.1 NVIDIA 53.36
extensions: GL_ARB_depth_texture GL_ARB_imaging GL_ARB_multisample
GL_ARB_multitexture GL_ARB_occlusion_query GL_ARB_point_parameters GL_ARB_point_sprite
GL_ARB_shadow GL_ARB_texture_border_clamp GL_ARB_texture_compression
GL_ARB_texture_cube_map GL_ARB_texture_env_add GL_ARB_texture_env_combine
GL_ARB_texture_env_dot3 GL_ARB_texture_mirrored_repeat GL_ARB_transpose_matrix
GL_ARB_vertex_buffer_object GL_ARB_vertex_program GL_ARB_window_pos GL_S3_s3tc
GL_EXT_texture_env_add GL_EXT_abgr GL_EXT_bgra GL_EXT_blend_color GL_EXT_blend_minmax
GL_EXT_blend_subtract GL_EXT_compiled_vertex_array GL_EXT_draw_range_elements
GL_EXT_fog_coord GL_EXT_multi_draw_arrays GL_EXT_packed_pixels GL_EXT_paletted_texture
GL_EXT_point_parameters GL_EXT_rescale_normal GL_EXT_secondary_color
GL_EXT_separate_specular_color GL_EXT_shadow_funcs GL_EXT_shared_texture_palette
GL_EXT_stencil_wrap GL_EXT_texture3D GL_EXT_texture_compression_s3tc
GL_EXT_texture_cube_map GL_EXT_texture_edge_clamp GL_EXT_texture_env_combine
GL_EXT_texture_env_dot3 GL_EXT_texture_filter_anisotropic GL_EXT_texture_lod
GL_EXT_texture_lod_bias GL_EXT_texture_object GL_EXT_vertex_array GL_HP_occlusion_test
GL_IBM_rasterpos_clip GL_IBM_texture_mirrored_repeat GL_KTX_buffer_region
GL_NV_blend_square GL_NV_copy_depth_to_color GL_NV_depth_clamp GL_NV_fence
GL_NV_fog_distance GL_NV_light_max_exponent GL_NV_multisample_filter_hint
GL_NV_occlusion_query GL_NV_packed_depth_stencil GL_NV_pixel_data_range
GL_NV_point_sprite GL_NV_register_combiners GL_NV_register_combiners2
GL_NV_texgen_reflection GL_NV_texture_compression_vtc GL_NV_texture_env_combine4
GL_NV_texture_rectangle GL_NV_texture_shader GL_NV_texture_shader2
GL_NV_texture_shader3 GL_NV_vertex_array_range GL_NV_vertex_array_range2
GL_NV_vertex_program GL_NV_vertex_program1_1 GL_NVX_ycrcb GL_SGIS_generate_mipmap
GL_SGIS_multitexture GL_SGIS_texture_lod GL_SGIX_depth_texture GL_SGIX_shadow
GL_SUN_slice_accum
----------------------------------------------------------------------
This test checks the logicop functions in RGBA mode.
logicOp: PASS rgba8, db, z24, s8, accrgba16, win+pmap, id 35
----------------------------------------------------------------------
This test checks that glClear works correctly with glColorMask,
glIndexMask, glDepthMask and glStencilMask.
maskedClear: PASS rgba8, db, z24, s8, accrgba16, win+pmap, id 35
----------------------------------------------------------------------
This test checks the positioning of random triangles under
orthographic projection. (This is important for apps that
want to use OpenGL for precise 2D drawing.) It fills in an
entire rectangle with an array of randomly-generated triangles,
drawing adjacent triangles with different colors and with blending
enabled. If there are gaps (pixels that are the background color,
and thus haven't been filled), overlaps (pixels that show a blend
of more than one color), or improper edges (pixels around the
edge of the rectangle that haven't been filled, or pixels just
outside the edge that have), then the test fails.
This test generally fails for one of several reasons. First,
the coordinate transformation process may have an incorrect bias;
this usually will cause a bad edge. Second, the coordinate
transformation process may round pixel coordinates incorrectly;
this will usually cause gaps and/or overlaps. Third, the
triangle rasterization process may not be filling the correct
pixels; this can cause gaps, overlaps, or bad edges.
orthoPosRandTris: PASS rgba8, db, z24, s8, accrgba16, win+pmap, id 35
Immediate-mode triangles: No gaps, overlaps, or incorrect edges.
----------------------------------------------------------------------
This test checks the positioning of axis-aligned rectangles
under orthographic projection. (This is important for apps
that want to use OpenGL for precise 2D drawing.) It fills in
an entire rectangle with an array of smaller rects, drawing
adjacent rects with different colors and with blending enabled.
If there are gaps (pixels that are the background color, and
thus haven't been filled), overlaps (pixels that show a blend
of more than one color), or improper edges (pixels around the
edge of the rectangle that haven't been filled, or pixels just
outside the edge that have), then the test fails.
This test generally fails for one of several reasons. First,
the coordinate transformation process may have an incorrect bias;
this usually will cause a bad edge. Second, the coordinate
transformation process may round pixel coordinates incorrectly;
this will usually cause gaps and/or overlaps. Third, the
rectangle rasterization process may not be filling the correct
pixels; this can cause gaps, overlaps, or bad edges.
orthoPosRandRects: PASS rgba8, db, z24, s8, accrgba16, win+pmap, id 35
Immediate-mode axis-aligned rectangles: No gaps, overlaps, or incorrect edges.
----------------------------------------------------------------------
This test checks the positioning of 1x1-pixel quadrilaterals
under orthographic projection. (This is important for apps
that want to use OpenGL for precise 2D drawing.) It fills in
an entire rectangle with an array of quadrilaterals, drawing
adjacent quads with different colors and with blending enabled.
If there are gaps (pixels that are the background color, and
thus haven't been filled), overlaps (pixels that show a blend
of more than one color), or improper edges (pixels around the
edge of the rectangle that haven't been filled, or pixels just
outside the edge that have), then the test fails.
This test generally fails for one of several reasons. First,
the coordinate transformation process may have an incorrect bias;
this usually will cause a bad edge. Second, the coordinate
transformation process may round pixel coordinates incorrectly;
this will usually cause gaps and/or overlaps. Third, the
quad rasterization process may not be filling the correct
pixels; this can cause gaps, overlaps, or bad edges.
orthoPosTinyQuads: PASS rgba8, db, z24, s8, accrgba16, win+pmap, id 35
Immediate-mode 1x1 quads: No gaps, overlaps, or incorrect edges.
----------------------------------------------------------------------
This test checks the positioning of unit-width horizontal lines
under orthographic projection. (This is important for apps
that want to use OpenGL for precise 2D drawing.) It fills in
an entire rectangle with a stack of horizontal lines, drawing
adjacent lines with different colors and with blending enabled.
If there are gaps (pixels that are the background color, and
thus haven't been filled), overlaps (pixels that show a blend
of more than one color), or improper edges (pixels around the
edge of the rectangle that haven't been filled, or pixels just
outside the edge that have), then the test fails.
This test generally fails for one of several reasons. First,
the coordinate transformation process may have an incorrect bias;
this usually will cause a bad edge. Second, the coordinate
transformation process may round pixel coordinates incorrectly;
this will usually cause gaps and/or overlaps. Third, the
line rasterization process may not be filling the correct
pixels; this can cause gaps, overlaps, or bad edges. Fourth,
the OpenGL implementation may not handle the diamond-exit rule
(section 3.4.1 in version 1.2.1 of the OpenGL spec) correctly;
this should cause a bad border or bad right edge.
It can be argued that this test is more strict that the OpenGL
specification requires. However, it is necessary to be this
strict in order for the results to be useful to app developers
using OpenGL for 2D drawing.
orthoPosHLines: PASS rgba8, db, z24, s8, accrgba16, win+pmap, id 35
Immediate-mode horizontal lines: No gaps, overlaps, or incorrect edges.
----------------------------------------------------------------------
This test checks the positioning of unit-width vertical lines
under orthographic projection. (This is important for apps
that want to use OpenGL for precise 2D drawing.) It fills in
an entire rectangle with a collection of vertical lines, drawing
adjacent lines with different colors and with blending enabled.
If there are gaps (pixels that are the background color, and
thus haven't been filled), overlaps (pixels that show a blend
of more than one color), or improper edges (pixels around the
edge of the rectangle that haven't been filled, or pixels just
outside the edge that have), then the test fails.
This test generally fails for one of several reasons. First,
the coordinate transformation process may have an incorrect bias;
this usually will cause a bad edge. Second, the coordinate
transformation process may round pixel coordinates incorrectly;
this will usually cause gaps and/or overlaps. Third, the
line rasterization process may not be filling the correct
pixels; this can cause gaps, overlaps, or bad edges. Fourth,
the OpenGL implementation may not handle the diamond-exit rule
(section 3.4.1 in version 1.2.1 of the OpenGL spec) correctly;
this should cause a bad border or bad top edge.
It can be argued that this test is more strict that the OpenGL
specification requires. However, it is necessary to be this
strict in order for the results to be useful to app developers
using OpenGL for 2D drawing.
orthoPosVLines: PASS rgba8, db, z24, s8, accrgba16, win+pmap, id 35
Immediate-mode vertical lines: No gaps, overlaps, or incorrect edges.
----------------------------------------------------------------------
This test checks the positioning of unit-sized points under
orthographic projection. (This is important for apps that
want to use OpenGL for precise 2D drawing.) It fills in an
entire rectangle one pixel at a time, drawing adjacent pixels
with different colors and with blending enabled. If there are
gaps (pixels that are the background color, and thus haven't
been filled), overlaps (pixels that show a blend of more than
one color), or improper edges (pixels around the edge of the
rectangle that haven't been filled, or pixels just outside the
edge that have), then the test fails.
This test generally fails for one of several reasons. First,
the coordinate transformation process may have an incorrect bias;
this usually will cause a bad edge. Second, the coordinate
transformation process may round pixel coordinates incorrectly;
this will usually cause gaps and/or overlaps. Third, the point
rasterization process may not be filling the correct pixels;
this can cause gaps, overlaps, or bad edges.
orthoPosPoints: PASS rgba8, db, z24, s8, accrgba16, win+pmap, id 35
Immediate-mode points: No gaps, overlaps, or incorrect edges.
----------------------------------------------------------------------
This test verifies that basic OpenGL operations such as the alpha
test, depth test, blending, stippling, and texturing work for
trivial cases.
paths: PASS rgba8, db, z24, s8, accrgba16, win+pmap, id 35
----------------------------------------------------------------------
This test verifies glPolygonOffset. It is run on every
OpenGL-capable drawing surface configuration that supports
creation of a window, has a depth buffer, and is RGB.
The first subtest verifies that the OpenGL implementation is
using a plausible value for the "minimum resolvable
difference" (MRD). This is the offset in window coordinates
that is sufficient to provide separation in depth (Z) for any
two parallel surfaces. The subtest searches for the MRD by
drawing two surfaces at a distance from each other and
checking the resulting image to see if they were cleanly
separated. The distance is then modified (using a binary
search) until a minimum value is found. This is the so-called
"ideal" MRD. Then two surfaces are drawn using
glPolygonOffset to produce a separation that should equal one
MRD. The depth values at corresponding points on each surface
are subtracted to form the "actual" MRD. The subtest performs
these checks twice, once close to the viewpoint and once far
away from it, and passes if the largest of the ideal MRDs and
the largest of the actual MRDs are nearly the same.
The second subtest verifies that the OpenGL implementation is
producing plausible values for slope-dependent offsets. The
OpenGL spec requires that the depth slope of a surface be
computed by an approximation that is at least as large as
max(abs(dz/dx),abs(dz/dy)) and no larger than
sqrt((dz/dx)**2+(dz/dy)**2). The subtest draws a quad rotated
by various angles along various axes, samples three points on
the quad's surface, and computes dz/dx and dz/dy. Then it
draws two additional quads offset by one and two times the
depth slope, respectively. The base quad and the two new
quads are sampled and their actual depths read from the depth
buffer. The subtest passes if the quads are offset by amounts
that are within one and two times the allowable range,
respectively.
polygonOffset: FAIL rgba8, db, z24, s8, accrgba16, win+pmap, id 35
Actual MRD is too small (may cause incorrect results)
Ideal MRD at near plane is 1.19209e-07 (nominally 2 bits)
Actual MRD at near plane is 5.96046e-08 (nominally 1 bit)
Ideal MRD at infinity is 5.86733e-08 (nominally 1 bit)
Actual MRD at infinity is 5.96046e-08 (nominally 1 bit)
----------------------------------------------------------------------
This test performs a sanity check of glReadPixels, using as
few other portions of the GL as possible. If this test fails,
it may be pointless to run other tests, since so many of them
depend on reading the contents of the framebuffer to determine
if they pass.
The test works by using glClear to fill the framebuffer with a
randomly-chosen value, reading the contents of the
framebuffer, and comparing the actual contents with the
expected contents. RGB, RGBA, color index, stencil, and depth
buffers (whichever are applicable to the current rendering
context) are checked. The test passes if the actual contents
are within 1 LSB of the expected contents.
readPixSanity: PASS rgba8, db, z24, s8, accrgba16, win+pmap, id 35
RGBA largest readback error was 0 bits
Depth largest readback error was 0 bits
----------------------------------------------------------------------
The OpenGL specification requires that under certain conditions
(e.g. lighting disabled, no clipping, no dithering, etc.) colors
specified as unsigned integers are represented *exactly* in the
framebuffer (up to the number of bits common to both the
original color and the framebuffer color channel). Several glean
tests depend on this behavior, so this test is a prerequisite for
them.
This test works by drawing many small quadrilaterals whose
colors are specified by glColorub, glColorus, and glColorui;
reading back the resulting image; and comparing the colors read
back to the colors written. The high-order bits shared by the
source representation of the colors and the framebuffer
representation of the colors must agree exactly for the test to
pass.
exactRGBA: FAIL rgba8, db, z24, s8, accrgba16, win+pmap, id 35
Unsigned short worst-case error was 0x100 at (0, 0)
expected (0xeb00, 0x5e00, 0xb300, 0x3600)
got (0xea00, 0x5e00, 0xb300, 0x3700)
Unsigned int worst-case error was 0x1000000 at (1, 0)
expected (0xff000000, 0xf4000000, 0xd0000000, 0xe6000000)
got (0xfe000000, 0xf4000000, 0xd0000000, 0xe5000000)
----------------------------------------------------------------------
The best approach when designing a test is to make it
self-checking; that is, the test itself should determine
whether the image or other data structure that it produces is
correct. However, some tests are difficult to design in this
way, and for some other tests (like stress tests or regression
tests concerning previously-reported bugs) it may be
unnecessary. For such tests, glean provides mechanisms to
save images and compare them to images generated from other
runs. This test simply exercises those mechanisms.
rgbTriStrip: NOTE rgba8, db, z24, s8, accrgba16, win+pmap, id 35
Image number 1
This test does not check its result. Please view
the image to verify that the result is correct, or
compare it to a known-good result from a different
run of glean.
----------------------------------------------------------------------
This test performs a basic test of the OpenGL scissor. It
checks for off-by-one errors around all four corners of the
scissored region, perhaps the most common cause of scissor
test failures.
glScissor( 0, 0, 10, 10 ):
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1
glScissor( 1, 1, 8, 8 ):
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0
0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0
0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0
0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0
0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0
0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0
0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0
0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
glScissor( 2, 2, 6, 6 ):
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0
0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0
0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0
0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0
0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0
0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0
scissor: PASS rgba8, db, z24, s8, accrgba16, win+pmap, id 35
----------------------------------------------------------------------
This test simply displays a teapot, rotates it, and attempts to
determine the frame/sec the pipeline can generate
teapot: PASS Teapots/Sec: 2721.77 rgba8, db, z24, s8, accrgba16, win+pmap, id 35
----------------------------------------------------------------------
GL_EXT_texture_env_combine verification test.
We only test a subset of all possible texture env combinations
because there's simply too many to exhaustively test them all.
texCombine: FAIL rgba8, db, z24, s8, accrgba16, win+pmap, id 35
expected 1, 0, 1, 0.5, got 0.996078, 0, 0.501961, 0.501961 in Single Texture
Test
Current combine state:
Incoming Fragment RGBA = 0, 0.25, 0.5, 0.75
Texture Unit 0:
GL_COMBINE_RGB_EXT = GL_ADD_SIGNED_EXT
GL_COMBINE_ALPHA_EXT = GL_ADD_SIGNED_EXT
GL_SOURCE0_RGB_EXT = GL_PRIMARY_COLOR_EXT
GL_SOURCE1_RGB_EXT = GL_TEXTURE
GL_SOURCE2_RGB_EXT = GL_CONSTANT_EXT
GL_SOURCE0_ALPHA_EXT = GL_TEXTURE
GL_SOURCE1_ALPHA_EXT = GL_TEXTURE
GL_SOURCE2_ALPHA_EXT = GL_CONSTANT_EXT
GL_OPERAND0_RGB_EXT = GL_SRC_COLOR
GL_OPERAND1_RGB_EXT = GL_SRC_COLOR
GL_OPERAND2_RGB_EXT = GL_SRC_ALPHA
GL_OPERAND0_ALPHA_EXT = GL_SRC_ALPHA
GL_OPERAND1_ALPHA_EXT = GL_SRC_ALPHA
GL_OPERAND2_ALPHA_EXT = GL_SRC_ALPHA
GL_RGB_SCALE_EXT = 4
GL_ALPHA_SCALE = 1
Tex Env RGBA = 0.25, 0.5, 0.75, 1
Texture RGBA = 1, 0, 0.25, 0.5
----------------------------------------------------------------------
GL_ARB_texture_cube_map verification test.
texCube: PASS rgba8, db, z24, s8, accrgba16, win+pmap, id 35
----------------------------------------------------------------------
Test basic texture env modes for all base texture formats.
texEnv: PASS rgba8, db, z24, s8, accrgba16, win+pmap, id 35
----------------------------------------------------------------------
This test verifies that the three basic OpenGL texture coordinate
modes: object_linear, eye_linear, and sphere_map, work for a simple
case.
texgen: PASS rgba8, db, z24, s8, accrgba16, win+pmap, id 35
----------------------------------------------------------------------
This test examines rendering performance for colored, textured,
flat-shaded triangles. It checks several different ways to
specify the vertex data in order to determine which is
fastest: fine-grained API calls, DrawArrays, DrawElements,
locked (compiled) DrawArrays, and locked DrawElements; for
independent triangles and for triangle strips. The test
result is performance measured in triangles per second for
each of the various vertex specification methods.
As a sanity-check on the correctness of each method, the test
colors each triangle with a unique color, and verifies that all
such colors are actually present in the final image. For
consistency, the test also verifies that the images are identical
for each of the specification methods.
coloredTexPerf2: PASS rgba8, db, z24, s8, accrgba16, win+pmap, id 35
Immediate-mode independent triangle rate = 3.3143e+06 tri/sec.
Range of valid measurements = [3.25079e+06, 3.3752e+06]
Image sanity check passed
Image consistency check passed
Display-listed independent triangle rate = 5.55321e+06 tri/sec.
Range of valid measurements = [5.55059e+06, 5.55688e+06]
Image sanity check passed
Image consistency check passed
DrawArrays independent triangle rate = 7.62678e+06 tri/sec.
Range of valid measurements = [7.62555e+06, 7.62821e+06]
Image sanity check passed
Image consistency check passed
Locked DrawArrays independent triangle rate = 7.63759e+06 tri/sec.
Range of valid measurements = [7.62939e+06, 7.6466e+06]
Image sanity check passed
Image consistency check passed
DrawElements independent triangle rate = 7.73276e+06 tri/sec.
Range of valid measurements = [7.72785e+06, 7.738e+06]
Image sanity check passed
Image consistency check passed
Locked DrawElements independent triangle rate = 7.74326e+06 tri/sec.
Range of valid measurements = [7.74042e+06, 7.74551e+06]
Image sanity check passed
Image consistency check passed
Immediate-mode triangle strip rate = 1.12297e+07 tri/sec.
Range of valid measurements = [1.12091e+07, 1.12473e+07]
Image sanity check passed
Image consistency check passed
Display-listed triangle strip rate = 1.66393e+07 tri/sec.
Range of valid measurements = [1.66353e+07, 1.66449e+07]
Image sanity check passed
Image consistency check passed
DrawArrays triangle strip rate = 2.33283e+07 tri/sec.
Range of valid measurements = [2.3321e+07, 2.3339e+07]
Image sanity check passed
Image consistency check passed
Locked DrawArrays triangle strip rate = 2.3335e+07 tri/sec.
Range of valid measurements = [2.33334e+07, 2.33368e+07]
Image sanity check passed
Image consistency check passed
DrawElements triangle strip rate = 2.30382e+07 tri/sec.
Range of valid measurements = [2.30313e+07, 2.30439e+07]
Image sanity check passed
Image consistency check passed
Locked DrawElements triangle strip rate = 1.48984e+07 tri/sec.
Range of valid measurements = [1.48697e+07, 1.4948e+07]
Image sanity check passed
Image consistency check passed
----------------------------------------------------------------------
This test examines rendering performance for colored, lit,
flat-shaded triangles. It checks several different ways to
specify the vertex data in order to determine which is
fastest: fine-grained API calls, DrawArrays, DrawElements,
locked (compiled) DrawArrays, and locked DrawElements; for
independent triangles and for triangle strips. The test
result is performance measured in triangles per second for
each of the various vertex specification methods.
As a sanity-check on the correctness of each method, the test
colors each triangle with a unique color, and verifies that all
such colors are actually present in the final image. For
consistency, the test also verifies that the images are identical
for each of the specification methods.
coloredLitPerf2: PASS rgba8, db, z24, s8, accrgba16, win+pmap, id 35
Immediate-mode independent triangle rate = 3.24327e+06 tri/sec.
Range of valid measurements = [3.22337e+06, 3.25441e+06]
Image sanity check passed
Image consistency check passed
Display-listed independent triangle rate = 1.0397e+07 tri/sec.
Range of valid measurements = [1.0396e+07, 1.03985e+07]
Image sanity check passed
Image consistency check passed
DrawArrays independent triangle rate = 6.53197e+06 tri/sec.
Range of valid measurements = [6.52682e+06, 6.54098e+06]
Image sanity check passed
Image consistency check passed
Locked DrawArrays independent triangle rate = 6.53286e+06 tri/sec.
Range of valid measurements = [6.53046e+06, 6.53675e+06]
Image sanity check passed
Image consistency check passed
DrawElements independent triangle rate = 6.59123e+06 tri/sec.
Range of valid measurements = [6.58578e+06, 6.59738e+06]
Image sanity check passed
Image consistency check passed
Locked DrawElements independent triangle rate = 6.559e+06 tri/sec.
Range of valid measurements = [6.53176e+06, 6.59715e+06]
Image sanity check passed
Image consistency check passed
Immediate-mode triangle strip rate = 1.0544e+07 tri/sec.
Range of valid measurements = [1.05247e+07, 1.05544e+07]
Image sanity check passed
Image consistency check passed
Display-listed triangle strip rate = 3.11953e+07 tri/sec.
Range of valid measurements = [3.11937e+07, 3.11984e+07]
Image sanity check passed
Image consistency check passed
DrawArrays triangle strip rate = 1.99501e+07 tri/sec.
Range of valid measurements = [1.99461e+07, 1.99532e+07]
Image sanity check passed
Image consistency check passed
Locked DrawArrays triangle strip rate = 1.99667e+07 tri/sec.
Range of valid measurements = [1.99617e+07, 1.99714e+07]
Image sanity check passed
Image consistency check passed
DrawElements triangle strip rate = 1.96756e+07 tri/sec.
Range of valid measurements = [1.96618e+07, 1.9685e+07]
Image sanity check passed
Image consistency check passed
Locked DrawElements triangle strip rate = 1.26154e+07 tri/sec.
Range of valid measurements = [1.25286e+07, 1.27635e+07]
Image sanity check passed
Image consistency check passed
-------------------------------------------------------
This SF.Net email sponsored by Black Hat Briefings & Training.
Attend Black Hat Briefings & Training, Las Vegas July 24-29 -
digital self defense, top technical experts, no vendor pitches,
unmatched networking opportunities. Visit www.blackhat.com
--
_______________________________________________
Dri-devel mailing list
[EMAIL PROTECTED]
https://lists.sourceforge.net/lists/listinfo/dri-devel
