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