JP2002519769A - Improved method and apparatus for pixel-by-pixel MIP mapping and three-line filtering - Google Patents

Abstract

(57) Summary The number of calculations performed in rendering graphics is reduced by calculating terms that are only at the start of each scanline. Only once at the start of each scan line is the scan line gradient of each of the two texture values for the x coordinate of the scan line calculated. After the scan line gradient calculation at the start position of each scan line, the pixel gradient of each pixel of the scan line with respect to the y coordinate of the scan line is calculated. The sum of the squares of the scan line gradients and the sum of the squares of the pixel gradients are compared, and the larger of the two quantities is selected as the maximum Rho constant term for the corresponding pixel, and the maximum Rho constant is Used to select a texture map for rendering the pixel to be rendered. In addition, at the start of each scan line, the respective pixel values of the two texture values for the first pixel of the scan line relative to the y coordinate of the scan line can be calculated. The derivative with respect to the pixel gradient is calculated, and the derivative is used to determine the pixel gradient, thereby eliminating the need to calculate the pixel gradient for each pixel.

Description

DETAILED DESCRIPTION OF THE INVENTION

[0001] The present invention relates to the field of computer graphics. In particular, the present invention discloses an improved method and apparatus for per-pixel MIP mapping and three-line filtering.

BACKGROUND [0002] Multimedia graphics are typically generated by processing an image as a collection of independently controlled small dots or pixels located on a screen or cathode ray tube. Computer graphic images typically consist of several target objects rendered on a background image. Each target object is composed of a plurality of pixels. During rendering, a compound technique can be used to combine a target object with an already generated target object, where combining is combining multiple images by superimposing or mixing the images. It is. In a composite image, the value of each pixel is calculated from the image components.

[0003] Three-dimensional (3D) computer graphics generally refers to a graphics environment that uses a rich set of colors, textures, correct viewpoints, and shadows. Typical 3
D graphics systems generally implement a set of techniques that allow computer graphics developers to create better, more realistic graphics environments. Some of these techniques are described in detail below.

[0004] A constituent unit of a 3D scene is a polygon. Polygons are flat shapes created using rendered pixels. For example, triangles are frequently used to create various shapes. Polygons use pixels that have a single color that looks flat, or pixels that are shaded so that the color changes gradually to appear darker based on distance or scene lighting. Can be rendered.

In constructing the triangles that form an image, each vertex or coordinate has a corresponding color value of a particular color model. A color model can be represented by a 3D color coordinate system and a visible subset in a coordinate system where all colors in a particular color gamut are present. In this case, the gamut is a subset of all visible chromaticities. For example, red (R),
The green (G) and blue (B) color models (RGB) are a unit cube subset of the 3D Cartesian coordinate system. The purpose of the color model is to allow colors to be conveniently specified within a certain color gamut. RGB primary colors are additive primaries in that the individual contributions of each primary color are added together to produce the resulting pixel. The color value of each pixel in the composite multimedia image is calculated in some way from the image components.

[0006] Texture mapping is a technique that allows 3D developers to create realistic, detailed and impressive scenes by scaling bitmap image files and mapping them onto polygons. is there. Instead of simply shading a polygon red, texture mapping can make it look like a realistic brick wall.

[0007] Multitum in parvo (MIP) mapping is a technique used to improve the visual quality of texture mapping while at the same time optimizing performance. The technique is that each texture map is rendered at a different resolution,
It works by having multiple texture maps for each texture.
In this case, the images are represented at different distances using different texture maps.
Bilinear filtering can also be used to improve the visual quality of texture mapping. Bilinear filtering uses the four surrounding texels obtained from the texture map to more precisely calculate the value of any given pixel in 3D space. A texel is a dot in a texture map, whereas a pixel is a dot on the screen.

[0008] Trilinear filtering is an advanced filtering technique that uses filtering into a third dimension. With three-line filtering, the resulting pixel is the average of the four surrounding texels from the two closest MIP maps. With three-line filtering, the visual quality of the texture mapping is improved, but unlike bilinear filtering, eight memory reads per pixel instead of four memory reads per pixel,
Calculations are needed to determine from which MIP map to read. Calculating this accurately is very costly. This calculation includes the level of detail (L
OD). In this case, the following equation is established.

(Equation 1) And LOD = log ₂ Rho Simplified to avoid finding the square root, these equations become:

(Equation 2) and

(Equation 3)

In order to accurately calculate Rho ′ for each pixel, du / dx, dv / dx, du / dy, and dv / dy are calculated using a multiplier and an adder. Calculate the square of each of these values using additional multipliers and adders. In systems with very high processing capabilities, the cost of performing four additional memory reads does not limit three-line filtering. However, in an environment with lower processing capacity, such as a personal computing environment, performance is always affected by performing three-line filtering. Therefore, an improved cost-effective method for performing three-line filtering without affecting performance is highly desirable.

SUMMARY OF THE INVENTION Three-line filtering performance is improved by calculating terms that are only at the start of each scanline and reducing the number of calculations performed when rendering graphics. Methods and apparatus are provided for per-pixel MIP mapping and three-line filtering. In one embodiment, only once at the start of each scan line is the scan line gradient of each of the two texture values relative to the x coordinate of the scan line calculated. After calculating the scan line gradient at the start of each scan line, a pixel gradient is calculated for each pixel of the scan line with respect to the y coordinate of the scan line. The sum of the square of the scan line gradient and the sum of the square of the pixel gradient are compared, and the larger of the two quantities is selected as the maximum Rho constant term for the corresponding pixel. Using the maximum Rho constant, Level of Detail (L) is set for each pixel of the scan line.
OD) is calculated. Using the LOD value of each pixel, a texture map for rendering the corresponding pixel is selected.

In an alternative embodiment, the scan line gradient of each of the two texture values is calculated only once at the start of each scan line, and after the scan line gradient calculation at each scan line start, the scan line is calculated. The pixel gradient is calculated for each of the two texture values for the first pixel of the scan line for the y coordinate of. The derivative with respect to the pixel gradient is calculated, and the derivative is used to determine the pixel gradient, thereby eliminating the need to calculate the pixel gradient for each pixel. The sum of the square of the scan line gradient and the sum of the square of the pixel gradient are compared, and the larger of the two quantities is selected as the maximum Rho constant term for the corresponding pixel. Maximum Rho
The LOD is calculated using a constant and the LOD value of each pixel is used to select a texture map for rendering the corresponding pixel.

In the accompanying drawings, the invention is illustrated by way of example and not by way of limitation. In the drawings, like reference numbers refer to similar elements.

DETAILED DESCRIPTION The present invention discloses an improved method and apparatus for per-pixel MIP mapping and three-line filtering. In the following detailed description, numerous specific details are set forth in order to provide a thorough understanding of the present invention. One skilled in the art will understand that the invention may be practiced without these specific details. In other instances, well-known structures, interfaces and processes have not been shown in detail in order not to unnecessarily obscure the present invention.

FIG. 1 is an embodiment of a computer system 1 on which the present invention is implemented.
The computer system 1 is connected to a system memory 2 by a system bus 30.
And a central processing unit (CPU) 10 coupled to the CPU. The CPU 10 and the memory 20 are coupled to a peripheral component interconnect (PCI) bus 40 via a bus interface 50 and a system bus 30. A graphics / video accelerator card 60 and various peripheral devices 80, 90 are coupled to the PCI bus 40. Graphics / video accelerator card 60 is coupled to display / monitor 70.

FIG. 2 illustrates exemplary circuits included in graphics / video accelerator card 60 of one embodiment, including circuits that perform various three-dimensional (3D) graphics functions. PCI interface 100 couples graphics / video accelerator card 60 to PCI bus 40. Graphics·
Processor 102 is coupled to PCI interface 100 and is designed to perform various graphics and video processing functions. Graphics processor 102 is typically a RISC (Reduced Instruction Set Computing) processor.

The pixel engine 120 is coupled to the graphics processor 102 and includes circuitry that performs various graphics functions, such as three-line filtering and MIP mapping, as described below. Local random access memory (RAM) 1
10 stores both the source pixel color value and the destination pixel color value. The destination color value is stored in the frame buffer 112 in the memory 100. In a preferred embodiment, a dynamic RAM (DRAM) is used as the memory 110. The display controller 114 has a RAM 110 and a first-in first-out buffer (FIFO)
116. Under the control of the display controller 114, the destination color values stored in the frame buffer 112 are supplied to the FIFO 116. The destination value stored in FIFO 116 is a set of digital-to-analog converters (
The digital-to-analog converter 118 outputs the red, green, and blue analog color signals to the monitor 70.

A memory controller 108 is also coupled to the RAM 110. The memory controller 108 controls the transfer of data between the RAM 110, the pixel engine 120, and both the graphics processor 102. The instruction cache 104 and the data cache 106 each include a graphics processor 102
And memory controller 108, each of which is used to store frequently used instructions and data. The data cache 106
It is also coupled to the CI interface 100 and the pixel engine 120.

In one embodiment, the pixel engine comprises a triangle engine. The triangle engine is 3
Used with the scanline algorithm to render D images. When rendering 3D images, multiple polygons or triangles are formed by rendering multiple pixels. A scanline algorithm is used to render the triangular pixels. FIG. 3 is a triangle 300 and corresponding scan lines 302 and pixels 304 of one embodiment. The triangle engine performs all calculations to render pixels, as described below.

Texture mapping is used to add visible detail to the composite image in computer graphics. The texture mapping of one embodiment includes a series of spatial deformations. This deformation is due to the fact that the texture plane [u, v] has a 3D surface [x
, Y, z] and then projected onto the output screen [x, y]. Texture mapping serves to create a complex appearance on an image simply by adding image detail on the surface, similar to wallpaper. Textures are commonly referred to as images used to map colors onto a target surface. In addition, textures are used to perturb the surface normals and thus simulate bumps and wrinkles without having to model such perturbations.

When rendering pixels in one embodiment, a MIP map is used to store the color image at multiple resolutions in memory. FIG. 4 is an embodiment of a MIP map memory configuration using the RGB color model. This MIP map supports trilinear interpolation. In this interpolation, the intra-level interpolation and the inter-level interpolation can be calculated using the three normalized coordinates u, v, and q. u and v are both spatial coordinates used to access a point in the texture map. The q coordinate is used to index the various levels of the pyramid and interpolate between those levels. In the RGB color model, the quadrant touching the eastern and southern boundaries contains the first red, green, and blue components of the color image. The remaining upper left quadrant contains all lower resolution copies of the original. Each level is indexed by a [u, v, q] coordinate system, but this embodiment is not so limited. Three-line interpolation or three-line filtering is
[u, v, q] coordinate system. The value of q is selected using an equation that balances the trade-off between aliasing and blurring, which computes the partial derivative using surface projection, as follows:

(Equation 4)

In one embodiment, three-line filtering is used to determine the resulting pixels from the four surrounding texels from the two closest MIP maps. In performing the three-line filtering of one embodiment, the maximum scale factor Rho is used to select the MIP level used to render a particular pixel. Rho is the maximum ratio between the source texel and the screen pixel, and is calculated using the following equation.

(Equation 5) However, this embodiment is not so limited. Level of detail (LO
D) is the actual MIP level selected and is defined as:

(Equation 6) However, this embodiment is not so limited.

The three-line filtering of one embodiment is implemented by using the law of business to show: du / dx = d ((u * q) / q) / dx = (q * du p / dx-u p * dq / dx) / (q * q) (3) In the above equation, u _p = u ^* q (i.e., u corrected by the repeated perspective in drawing the triangle). Similarly, the following equation is given. ^{dv / dx = (q * dv} p / dx-vp * dq / dx) / (q * q) (4) du / dy = (q * du p / dy-up * dq / dy) / (q * q ) and (5) dv / dy = ( q * dv p / dy-vp * dq / dy) / (q * q) (6)

According to one embodiment of the present invention, based on the above definitions, the following terms are defined. _{^{c1 = (q * du p /}} dx-u p * dq / dx) (7) c2 = (q * dv p / dx-v p * dq / dx) (8) c3 = (q * du p / dy- in u _p ^* dq / dy) and ^{(9) c4 = (q *} dv p / dy-v p * dq / dy) (10) the above equation, u and v are the texture values, x and y are texels The screen position value, and q is a distance value. Therefore, the following equations are shown using Equations 7 to 10. Rho '= MAX [(c1 ^* c1 + c2 ^* c2) / (q ^* q ^* q ^* q), (11) (c3 ^* c3 + c4 ^* c4) / (q ^* q ^* q ^* q)] (12) It means the following equation. Rho '= MAX [(c1 ^* c1 + c2 ^* c2), (c3 ^* c3 + c4 ^* c4)
] / (Q ^* q ^* q ^* q) (13) and

(Equation 7)

According to a first embodiment of the present invention, by calculating terms that are only at the start of each scanline, rather than at all points of the triangle, the calculations performed when rendering graphics are performed. The number is reduced, thereby improving the performance of the three-line filtering. The derivatives of c1 and c2 in the above equation are zero, so c1 and c2 are constants along the scanline, where the scanline has a single value along the y-axis , And values that increase and decrease along the x-axis. Thus, according to one embodiment, the quantity (c1 ^* c1 + c2 ^* c2) is calculated only once at the start of each scan line, whereas the quantity (c3 ^* c)
3 + c4 ^* c4) is calculated for each point or each pixel along the scan line. The quantity (c1 ^* c2 + c2 ^* c2) need only be calculated once for each scan line, and the calculation of the quantity (c3 ^* c3 + c4 ^* c4) follows the above calculation for each pixel along the scan line. In the embodiment, the quantity (c1 ^* c
The same multiplier unit can be used in calculating 1 + c2 ^* c2) and quantity (c3 ^* c3 + c4 ^* c4). This is because these values are not calculated simultaneously.

FIG. 5 is a flowchart relating to pixel rendering using three-line filtering according to the first embodiment. The operation starts at step 502 where a polygonal scanline to be rendered is selected. At the start of each scan line,
The triangle engine calculates, at step 504, the scanline gradient of each of the two texture values for the x-coordinate of the scanline using Equations 7 and 8. Quantity using these scan line gradients (c1 ^* c1 + c2 ^* c2)
Is calculated. In one embodiment, these calculations are performed using six multiplications, two subtractions, and one addition for each scan line, although this embodiment is not so limited. Absent. Since this embodiment uses six multipliers, Rho can be calculated in a single clock cycle.

After calculating the scan line gradient at the start of each scan line, the triangle engine calculates, at step 506, the pixel gradient of each pixel of the scan line relative to the y coordinate of the scan line. The pixel gradient is calculated for each of the two texture values using Equations 9 and 10. Using this pixel gradient, the quantity (
c3 ^* c3 + c4 ^* c4) is calculated. In step 508, the quantity (c1 ^* c1 +
c2 ^* c2) is compared with the quantity (c3 ^* c3 + c4 ^* c4), and at step 510,
The larger of the two quantities is selected as the maximum Rho constant term for the corresponding pixel. In one embodiment, the maximum Rho constant calculation is performed using six multiplications, two subtractions, one addition, and one comparison operation for each pixel,
This embodiment is not so limited.

After determining the maximum Rho constant, the triangle engine calculates LOD for each pixel of the scan line using Equation 2 at step 512. The LOD value of each pixel is used at step 514 to select a texture map to render the corresponding pixel. The pixels are rendered at step 516. At step 518, it is determined whether all pixels of the scan line have been rendered. If not all pixels of the current scan line have been rendered, operation proceeds to step 506, where a pixel gradient is calculated for the other pixels of the scan line. If all pixels of the current scanline have been rendered, operation proceeds to step 520, where it is determined whether all scanlines of the current polygon have been rendered. If not all scanlines of the current polygon have been rendered,
The operation proceeds to step 502, where a new scan line of the polygon is selected as the scan line to be rendered. If all scanlines of the current polygon have been rendered, the operation for the current polygon ends.

According to a second embodiment of the present invention, the number of calculations performed in rendering graphics by calculating a term only at the start of each scanline, rather than at every point of the triangle Reduces the performance of the three-line filtering. As described above, c1 and c2 are constants along the scan line, so the quantity (c1 ^* c1 + c2 ^* c2) is calculated only once at the start of each scan line. Further, c3 and c in Expression 9 and Expression 10
Note that 4 is a linear quantity. Therefore, when the quantity (c3 ^* c3 + c4 ^* c4) is calculated at the pixel (x, y), that is, the start position of the scan line, the following equation is obtained for the pixel (x + 1, y), that is, the next pixel on the scan line. ^{enacted, (c3 * c3 + c4 *} c4) = [(c3 + delta_c3) * (c3 + delta_c3) + (c4 + delta_c4) * (c4 + delta_c4)] = [c3 * c3 + 2 * c3 * delta_c3 + delta_c3 * delta_
c3 + c4 ^* c4 + 2 ^* c4 ^* delta_c4 + delta_c4 ^* delta_
c4] (15) The following expression holds for the pixel (x + 2, y). ^{(C3 * c3 + c4 * c4} ) = [(c3 + delta_c3) * (c3 + delta_c3) + (c4 + delta_c4) * (c4 + delta_c4)] = [c3 * c3 + 4 * c3 * delta_c3 + 4 * delta_c3 * delt
a_c3 + c4 ^* c4 + 4 ^* c4 ^* delta_c4 + 4 ^* delta_c4 ^* de
lta_c4] (16) Therefore, when the derivatives of c3 and c4 are calculated at the start position of each scan line, c3 and c4 are not calculated for each pixel along the scan line.

FIG. 6 is a flowchart relating to pixel rendering using three-line filtering according to the second embodiment. The operation starts at step 602, where a polygonal scanline to be rendered is selected. At the start of each scan line,
The triangle engine calculates the scanline gradient of each of the two texture values for the x-coordinate of the scanline using Equations 7 and 8 at step 604. Using these scan line gradients, the quantity (c1 ^* c1 + c2 ^* c2)
) Is calculated. After calculating the scan line gradient at the start of each scan line, the triangle engine calculates, at step 606, the pixel gradient of the first pixel of the scan line relative to the y coordinate of the scan line. The pixel gradient is calculated for each of the two texture values using Equations 9 and 10. At step 608, the derivative with respect to the pixel gradient is calculated according to: ^{delta_c3 = (dq / dx * du} p / dy-du p / dx * dq / dy)
(17) delta_c4 = (dq / dx * dv p / dy-dv p / dx * dq / dy)
(18) The pixel gradient is determined for each pixel using this derivative, thus eliminating the need to separately calculate the pixel gradient for each pixel. The quantity (c1 ^* c1 + c2 ^* c2) is calculated using the scan line gradient and the quantity (c3 ^* c3 + c4 ^* c4) is
Calculated using pixel gradient. In one embodiment, these calculations are performed using 20 multiplications, 6 subtractions, 5 additions, and 2 left shift operations for each scan line, but this embodiment does this. It is not so limited.
In one embodiment, the maximum Rho constant is calculated over two clock cycles for each scanline using ten multipliers, the calculation being continuous while the pixel is being rendered for the current scanline. It can be performed on scan lines.

In step 610, the quantity (c1 ^* c1 + c2 ^* c2) is compared to the quantity (c3 ^* c3 + c4 ^* c4), and in step 612 the greater of the two quantities is the maximum Rho constant for the corresponding pixel. Selected as a term. In one embodiment, the maximum Rho constant calculation is performed using two additions and one comparison operation for each pixel, but this embodiment is not so limited.

After determining the maximum Rho constant, the triangle engine determines in step 614 that
Is used to calculate the LOD for each pixel of the scan line. The LOD value of each pixel is used in step 616 to select a texture map to render the corresponding pixel. The pixels are rendered at step 618. At step 620, it is determined whether all pixels of the scan line have been rendered. If not all pixels of the current scanline have been rendered, the operation proceeds to step 610. If all pixels of the current scanline have been rendered, the operation proceeds to step 622, where it is determined whether all scanlines of the current polygon have been rendered. If not all scanlines of the current polygon have been rendered, operation proceeds to step 602, where a new scanline of the polygon is selected as the scanline to render. If all scanlines of the current polygon have been rendered, the operation for the current polygon ends.

Thus, a method and apparatus for per-pixel MIP mapping and three-line filtering is disclosed. These specific structures and methods described herein are merely illustrative of the principles of the present invention. Numerous modifications in form and detail can be made by those skilled in the art without departing from the scope of the invention. Although the invention has been described with reference to certain preferred embodiments, the invention should not be deemed to be so limited. The invention is limited only by the appended claims.

[Brief description of the drawings]

FIG. 1 is a diagram illustrating one embodiment of a computer system on which the present invention is implemented.

FIG. 2 illustrates an exemplary circuit included in a graphics / video accelerator card of one embodiment.

FIG. 3 illustrates a triangle and corresponding scan lines and pixels of one embodiment.

FIG. 4 illustrates an embodiment of a MIP map memory configuration using an RGB color model.

FIG. 5 is a flowchart relating to pixel rendering using three-line filtering according to the first embodiment;

FIG. 6 is a flowchart relating to pixel rendering using three-line filtering according to the second embodiment.

──────────────────────────────────────────────────続 き Continuation of front page (81) Designated country EP (AT, BE, CH, CY, DE, DK, ES, FI, FR, GB, GR, IE, IT, LU, MC, NL, PT, SE ), OA (BF, BJ, CF, CG, CI, CM, GA, GN, GW, ML, MR, NE, SN, TD, TG), AP (GH, GM, KE, LS, MW, SD, SL, SZ, UG, ZW), EA (AM, AZ, BY, KG, KZ, MD, RU, TJ, TM), AE, AL, AM, AT, AU, AZ, BA, BB, BG, BR , BY, CA, CH, CN, CU, CZ, DE, DK, EE, ES, FI, GB, GD, GE, GH, GM, HR, HU, ID, IL, IN, IS , JP, KE, KG, KP, KR, KZ, LC, LK, LR, LS, LT, LU, LV, MD, MG, MK, MN, MW, MX, NO, NZ, PL, PT, RO, RU, SD, SE, SG, SI, SK, SL, TJ, TM, TR, TT, UA, UG, UZ, VN, YU, ZA, ZW (72) Inventor Jan, Stephen United States 94439 California・ Fremont Wagner Street ・ 663 F-term (reference) 5B080 AA14 CA05 DA06 FA02 GA22

Claims (26)

[Claims] 1. A method for generating three-dimensional (3D) graphics, comprising: providing a scan line gradient only once at a start position of a scan line for each of a plurality of texture values with respect to a first position coordinate of the scan line. And selecting one texture map from the plurality of texture maps to use in rendering the pixels; and maximizing the scale to select the texture map to render the pixels.
Calculating a maximum scale factor for each pixel using a factor, using a scan line gradient and using at least one of the pixel gradient and the derivative of the pixel gradient. 2. A scan line slope is calculated for each of the two texture values only once at the start of the scan lines, the scan lines gradient is calculated using the following _{^{formula, c1 = (q * du p}} / in ^{_{dx-u p * dq / dx}} ) c2 = (q * dv p / dx-v p * dq / dx) the above equation, u and v are the texture values, x and y are located at the texel screen position value , Q is a distance value. 3. The pixel gradient of each of the plurality of texture values for a second position coordinate of the scan line is calculated only once for each pixel of the scan line;
2. The pixel gradient is used to calculate a maximum scale factor.
The method described in. 4. A pixel gradient is calculated for each of the two texture values, the scan line pixel gradient is calculated using the following _{^{equation, c3 = (q * du p}} / dy-u p * dq / dy) c4 = in _{^{(q * dv p / dy-}} v p * dq / dy) the above equation, u and v is the texture values, x and y are screen position value of texel, claim q is a distance value 3. The method according to 3. 5. The maximum scale factor is Rho, where Rho is the maximum ratio of source texel to screen pixel, and Rho is calculated using the following equation: Rho = MAX [(c1 ^* c1 + c2 ^* c2), (c3 ^* c3 + c4 ^* c4)] /
(Q ^* q) The method of claim 4. 6. The derivative of the pixel gradient is calculated for each of the plurality of texture values, once for each scan line, once at the start of the scan line, and wherein the derivative of the pixel gradient is a maximum scale factor. 2. The method according to claim 1, which is used to calculate 7. A pixel derivative of the gradient is calculated for each of the two texture values, said derivative of said pixel gradient is calculated using the following equation, delta c3 = (dq / dx * du p / in ^{_{dy-du p / dx * dq}} / dy) delta c4 = (dq / dx * dv p / dy-dv p / dx * dq / dy) the above equation, u and v are the texture values, x and y are 7. The method of claim 6, wherein the texel is a screen position value and q is a distance value. 8. The method of claim 1, further comprising generating a plurality of texture maps for each of the plurality of textures, wherein each texture map is rendered at a different resolution. 9. The method according to claim 1, wherein the first position coordinate is an X coordinate and the second position coordinate is a Y coordinate. 10. The method further includes calculating a level of detail (LOD), where LOD = log ₂ (Rho), wherein the LOD is used to select a texture map for rendering pixels. The method of claim 1. 11. A memory and a processor subsystem coupled to the memory and coupled to the memory to select one texture map to be used in rendering a pixel of the plurality of texture maps. Calculating, for each scan line, only once at a start position of the scan line, a scan line gradient of each of a plurality of texture values for a first position coordinate of the scan line; Calculating a maximum scale factor for each pixel using the line gradient and using the pixel gradient and / or a derivative of the pixel gradient, wherein the maximum scale factor is a texture map for rendering the pixel; Computer system used to select the. 12. The processor subsystem calculates the scan line gradient of each of the two texture values only once at the start of the scan line, and the scan line gradient is calculated using the following equation: c1 = in _{^{(q * du p / dx-}} u p * dq / dx) c2 = (q * dv p / dx-v p * dq / dx) the above equation, u and v are the texture values, x and y are texels The computer system according to claim 11, wherein the screen position value is a distance value and q is a distance value. 13. The processor subsystem calculates a pixel gradient of each of the plurality of texture values for a second position coordinate of the scan line only once for each pixel of the scan line, wherein the pixel gradient is at a maximum. The computer system of claim 11, used to calculate a scale factor. 14. The pixel gradient is calculated for each of the two texture values, the scan line pixel gradient is calculated using the following _{^{equation, c3 = (q * du p}} / dy-u p * dq / dy) c4 = in _{^{(q * dv p / dy-}} v p * dq / dy) the above equation, u and v is the texture values, x and y are screen position value of texel, claim q is a distance value 14. The computer system according to claim 13. 15. The maximum scale factor is Rho, where Rho is the maximum ratio of source texel to screen pixel, and Rho is calculated using the following equation: Rho = MAX [(c1 ^* c1 + c2 ^* c2), (c3 ^* c3 + c4 ^* c4)] /
(Q ^* q) The computer system according to claim 14. 16. The processor system calculates, for each scanline, a derivative of a pixel gradient of each of a plurality of texture values, once at a start position of the scanline, wherein the derivative of the pixel gradient is 12. The computer system of claim 11, which is used to calculate a maximum scale factor. 17. The processor subsystem calculates a derivative of a pixel gradient for each of two texture values, wherein the derivative of the pixel gradient is calculated using the following equation: delta c3 = (dq / in _{^{dx * du p / dy-du}} p / dx * dq / dy) delta c4 = (dq / dx * dv p / dy-dv p / dx * dq / dy) the above equation, u and v are located in texture value 17. The computer system according to claim 16, wherein x, y and y are screen position values of texels, and q is a distance value. 18. The processor subsystem further generates a plurality of texture maps for each of the plurality of textures, wherein each texture map is rendered at a different resolution, wherein LOD = log ₂ (Rho), 12. The method of claim 11, wherein the method is configured to calculate a level of detail (LOD) used to select a texture map for rendering. 19. A computer-readable medium containing executable instructions that, when executed in a processing system, cause the system to perform the steps of generating three-dimensional (3D) graphics, the steps comprising: For each line, only once at the start of the scan line, calculate the scan line gradient of each of the plurality of texture values relative to the first position coordinate of the scan line and render the pixels of the plurality of texture maps. Selecting a single texture map to use in conjunction with the scan line gradient and the pixel scale and the maximum scale factor used to select the texture map to render the pixel. A maximum scan for each pixel using at least one of the derivatives of the pixel gradient. Computer readable media comprising calculating an Lumpur factor. 20. The system according to claim 1, wherein the instruction is provided to the system at the start of the scan line.
Every time only, to calculate the respective scan lines gradient of two texture values, the scan line gradient is calculated using the following _{^{formula, c1 = (q * du p}} / dx-u p * dq / dx) c2 = ( in _{^{q * dv p / dx-v}} p * dq / dx) the above equation, u and v is the texture values, x and y are screen position value of texel claim 19 q is a distance value Computer readable media. 21. The instructions cause the system to calculate a pixel gradient of each of a plurality of texture values for a second position coordinate of the scan line only once for each pixel of the scan line, wherein the pixel gradient is: 20. The computer system according to claim 19, used to calculate a maximum scale factor. 22. wherein the instructions, to calculate the pixel gradient for each of the two texture values to the system, the scan line pixel gradient is calculated according to the following _{^{equation, c3 = (q * du p}} / dy-u p * dq / dy) with _{^{c4 = (q * dv p /}} dy-v p * dq / dy) the above equation, u and v is the texture values, x and y are screen position value of texel, q is a distance value A computer readable medium according to claim 21. 23. The maximum scale factor is Rho, where Rho is the maximum ratio of source texels to screen pixels, and the instructions cause the system to calculate Rho according to: Rho = MAX [sqrt (C1 ^* c1 + c2 ^* c2), sqrt (c3 ^* c3 + c4 ^* c4)] / (q ^* q) The computer-readable medium according to claim 22. 24. The instructions cause the system to calculate, for each scan line, a derivative of a pixel gradient of each of a plurality of texture values, once at a start position of the scan line, wherein the derivative of the pixel gradient is calculated. 20. The computer-readable medium of claim 19, wherein is used to calculate a maximum scale factor. 25. The instructions cause the system to calculate the derivative of the pixel gradient for each of two texture values, and the derivative of the pixel gradient is calculated according to: delta c3 = (dq / dx ^* in _{du p / dy-du p /} dx * dq / dy) delta c4 = (dq / dx * dv p / dy-dv p / dx * dq / dy) the above equation, u and v are the texture value, x The computer-readable medium of claim 24, wherein and y are texel screen position values and q is a distance value. 26. The instructions further comprising: generating a plurality of texture maps for each of a plurality of textures, wherein each texture map is rendered at a different resolution; LOD = log ₂ (Rho). 20. The computer-readable medium of claim 19, comprising causing a step of calculating a level of detail (LOD) used to select a texture map for rendering pixels.