JP4767123B2 - A computer graphics circuit and a three-dimensional computer that uses this circuit to generate a two-dimensional pseudo-random texture pattern applied to a three-dimensional object displayed on a two-dimensional display system using a one-dimensional texture image Graphics equipment - Google Patents

Description

  The present invention relates to the generation of pseudo-random texture patterns. A one-dimensional texture image is used as a framework for generating a two-dimensional image texture. More precisely, the two-dimensional image texture is generated using a special projection method that projects the one-dimensional texture onto the two-dimensional texture image.

  In computer graphics, geometric objects are displayed on a two-dimensional display system. Geometric figures are often combined with textures to improve the realism of the resulting image. The texture appears to be painted on the surface of the object as an image or pattern. For example, to draw a mountain on a two-dimensional display system, a quadrilateral can be used as a shape and a mountain image can be used as a texture. Mountain images can be added to shapes using texture coordinates. One texture coordinate is defined for each point of the shape. This texture coordinate also defines the placement in the image. The association between the geometric space and the image space is called texture mapping. In conventional computer graphics systems, geometric objects are drawn and points in the texture image are used by using the corresponding texture coordinates for each point of the object corresponding to the point on the two-dimensional display system. And as a result a certain color is obtained. This color is then displayed. This description is very simplified. Texturing and texture mapping are common techniques in computer graphics. For example, see Non-Patent Document [Non-Patent Document 1]. This technique is hereinafter referred to as static two-dimensional texture.

  Mapping a two-dimensional texture image to an object is used extensively in computer graphics and is very effective. However, for some objects, this technique may not be optimal. For example, if you consider a wall, it shows the same pattern everywhere, and there is only a slight change, that is, a wall made of brick and mortar seems to show the same brick / mortar everywhere, but look carefully (For example, the mortar is a little thicker). In order to generate such a repetitive but different pattern, there are alternative means (or extension means) for the two-dimensional texture. It is called procedural texture. Instead of using static two-dimensional images, a function (procedure) is used to generate some pseudo-random patterns. The description of the procedural texture technique is described in Non-Patent Document 2 (D. Ebert et al. “Texturing and Modeling: Procedural Method”). This technique is hereinafter referred to as procedural texture. The procedural texture can be used in combination with a two-dimensional texture. After the procedural function perturbs the input texture coordinates, the perturbed input coordinates are used to define the output color using the two-dimensional texture image.

  In both static and procedural techniques, various calculations are performed to define an output color for each given input texture coordinate (u, v). A static two-dimensional texture is mainly composed of a mapping function for defining a certain color by mapping a texture coordinate to a certain point in the image space. As a procedural function, for example, an input coordinate ( A special function is defined that maps u, v) to (u ′, v ′), after which (u ′, v ′) is used for the texture mapping function.

  In this document, we propose a new texturing technique that exists between a static two-dimensional texture and a procedural texture, and also a new texture mapping technique. This new technology can be summarized as follows. Given some input texture coordinates (u, v), first perturb (u, v) using a noise function, and after obtaining (u ', v'), a special mapping unit The two-dimensional texture coordinates (u ′, v ′) are mapped to the one-dimensional texture coordinates (t). Next, a one-dimensional texture image is designated using the one-dimensional texture coordinates.

  By using this new technique, interesting textures can be obtained. It can be classified into two different types.

  If no perturbation is given, a normal geometric texture is obtained. Examples of such textures are, for example, glare, flare, halo, or repetitive motifs (squares, circles, etc.) on a thin fabric surface. No patent literature was found regarding a specific two-dimensional to one-dimensional mapping function.

  When perturbations are used, natural looking textures such as wood and marble are obtained. The visual result obtained by using the perturbation module is close to the result proposed in Non-Patent Document 2 (D. Ebert et al. “Texturing and Modeling: Procedural Method”). What is proposed in this document is based on a perturbation module. The operation of this module is somewhat similar to the noise function proposed in the patent document (K. Perlin “Method and Apparatus for Noise Handling”) W0 01/39126 A1 (Patent Document 1). The input and output are similar, but the means for obtaining the output value is different. The noise function depends on three steps. For example, some hash value is calculated, a gradient is calculated, and these values are interpolated to obtain one value. One embodiment of the present invention is a variation of these steps. The calculation of the hash value depends on the permutation table, and the hash value is used to calculate the gradient. One preferred embodiment of the present invention is based on a very simple random number generation and weighting function of these random numbers without using a table or gradient. Another embodiment of the invention refers to an interpolation technique and proposes a specific circuit that increases the perturbation parameterization and thus improves the appearance of the resulting texture. When all the embodiments are combined, a module different from the noise module proposed in Patent Document W0 01/39126 A1 (Patent Document 1) is specified.

Other similar modules are defined in the patent literature (K. Perlin “Perlin Noise Standards” US Pat. No. 6,867,776 B2 (Patent Literature 2).
Similar to 01/39126 A1 (Patent Document 1), hash values and gradients are used. One preferred embodiment of the present invention does not use hash values and gradients, but is based on weighted random values. The method described in Patent Document 2 does not use bilinear interpolation, but uses a function called a spherical kernel instead.

Perlin Kenneth, “Noise Handling Method and Device” International Publication No. WO 01/39126 A1 Perlin Kenneth, “Perlin Noise Standards” US Pat. No. 6,867,776 B2 J.D. Foly, A. Van Dam, S.K. Feiner, and J.F. Hugues "Computer Graphics: Principles and Practices" 2nd edition, ADDISON-WESLY, ISBN: 0-201-84840-6,1995. D. Ebert et al. “Texturing and Modeling: Procedural Method” 3rd edition, Morgan Kaufmann Publishers, ISBN1-55860-848-6, 2003

  In computer graphics, when creating and displaying a two-dimensional texture image, a module called a texture unit is generally used. In this method, an index for accessing a specific position of a two-dimensional image stored in a memory is calculated using two-dimensional coordinates (u, v), so-called texture coordinates. Index calculation requires enormous calculation, and storing a two-dimensional image is expensive from the viewpoint of memory. This technique is static, that is, has very few configuration parameters for obtaining various image results depending on the two-dimensional image stored in the memory.

  For so-called natural textures such as wood and stone, there is another technique called procedural texture. However, creating a procedural texture often requires a programmable circuit (called a fragment shader). Such a general-purpose programmable hardware circuit usually forms an important part of the graphic chip and is very large from the viewpoint of the size of the hardware.

  A concern of the disclosed invention is the generation of natural textures or pseudo-random repetitive textures, and even textures that exhibit geometric regularity (eg, glare, flare, halo, or print on thin fabric surfaces) Generated repetitive motifs). Both static two-dimensional textures and procedural textures can create such textures. In the proposed invention, it is proposed to fill a gap in order to generate a two-dimensional texture image. This is a trade-off between a completely static 2D texture and a procedural texture. The set of circuits disclosed in this document provides several configuration parameters but is more flexible than static two-dimensional textures (but less flexible than procedural textures defined in fragment shaders) ) On a much smaller circuit scale than a fragment shader (and also a static 2D texture).

  The system used to solve the problem of memory size and circuit scale requirements can be broken down as follows. To solve the problems listed in the previous section, a combination of three measures is used.

Use one-dimensional textures instead of two-dimensional textures to ease memory size requirements.
A dedicated circuit that perturbs the input 2D texture coordinates is used to perform visible deformations in the resulting 2D texture.

  The one that can be set (changed) by a dedicated mapping circuit is used, and the perturbed two-dimensional texture coordinates are mapped to the one-dimensional output texture coordinates, which are used for addressing the one-dimensional texture image stored in the memory.

First aspect: Procedural one-dimensional pseudo-random pattern generation The first aspect of the present invention is a system for calculating two-dimensional texture coordinates in a computer system, and includes two-dimensional texture coordinates (u , v), a second means for generating two one-dimensional intervals (intervals) of two random values using the coordinates u and v, and two one-dimensional intervals of the random values A third means for generating one two-dimensional section of four random values, and a fourth means for generating a random value according to the two-dimensional sections of the texture coordinates (u, v) and the four random values. And a fifth means for combining the random value and the input texture coordinates (u, v) to obtain the transformed two-dimensional texture coordinates (u ′, v ′). System.

  One of the preferred examples of the first aspect of the present invention is that, in the above, the second means inputs either u or v coordinates and inputs two random values (u0, u1) and (v0, v1). ) Of two random number generators that are separated but similar (identical), and the third means includes the random values (u0, u1) and (v0, v1) It is a system characterized by combining two one-dimensional sections to obtain a two-dimensional section [(u0, v0), (u1, v1)].

In a preferred example of the first aspect of the present invention, in the above description, the second means inputs either u or v coordinates (hereinafter sometimes referred to as “t”) and receives two random values. A means for obtaining a one-dimensional section of (u0, u1) and (v0, v1), comprising two separate but similar random number generators, where each random number generator has two numerical values Means for calculating TA and TB from the input value “t”, wherein TB is a floating-point value less than 1 and TA + TB is equal to 1, and means for projecting the value TB to a random value TT; Means for calculating two numerical values TTA and TTB from the value TT, wherein TTB is a floating-point value less than 1 and TTA + TTB is equal to 1, and means for generating a random value, the set of parameters { Generating two random values T1 and T2 as a result of using TA, TTA} and {TA, TTA + 1}, wherein the third means comprises a random value (u (0, u1) and (v0, v1) are two means to obtain a two-dimensional interval [(u0, v0), (u1, v1)] by combining two one-dimensional intervals, which are constant integer values. Means using what is hereinafter referred to as "magic_mask", means for calculating two new numerical values, hereinafter referred to as "maskA" and "maskB", using the two random values u0 and u1, A means for calculating a random value, comprising four sets of inputs {u0, v0, maskA}, {u0, v1, maskA},
{u1, v0, maskB}, and {u1, v1, maskB} resulting in random values R1, R2, R3, and R4, wherein the fifth means comprises UUB and Means for obtaining a VVB from the random number generator, wherein the pre-specified value TTB is equal to UUB when the coordinate u is used as an input to the random number generator, and similarly, the random number generator Is a means for calculating a weighted random value that is equal to VVB when the coordinate v is used as an input, and includes four sets of inputs {R1, UUB, VVB}, {R2, UUB-1.0, VVB} , {R3, UUB, VVB-1.0}, and {R4, UUB-1.0, VVB-1.0} to obtain four weights r1, r2, r3 and r4 as a result, and random value RV to r1, A means for calculating using r2, r3, r4, UUB, and VVB as inputs, comprising a bilinear interpolation module, r1,
r2, r3 and r4 are interpolated values, and UUB and VVB are interpolation parameters, and the system controls the generation of the random value, the input coordinates (u , v) and a means for changing the output value RV, and the fifth means combines the RV and the input coordinates (u, v) to It is a system that is a means for obtaining the output (u ′, v ′).

In a preferred example of the first aspect of the present invention, in any one of the above, the system is a means for controlling the generation of the random value, and means for changing the input coordinates (u, v). A means for performing scaling, translation, and clamping operations for each input u and v to obtain a scaling and translation coefficient and a clamping operation type; and a means for changing the output value RV. Further comprising: means for performing scaling and translation operations to obtain a scaling factor and a clamping operation type, wherein the second means is one of u or v coordinates (hereinafter, Is also a means to obtain a one-dimensional section of two random values (u0, u1) and (v0, v1) by inputting 2 random number generators, where each random number generator is a means for calculating two numerical values TA and TB from the input value “t”, and is a floating point value with TB less than 1. TA + TB equal to 1, means for projecting the value TB to a random value TT, a means for obtaining a constant value, hereinafter referred to as magic_shift1, and as a result of projecting TB into the interval [0, magic_shift1] TT Means for calculating two numerical values TTA and TTB from the value TT, where TTB is a floating-point value less than 1 and TTA + TTB is equal to 1, and a random value Means for generating two random values T1 and T2 as a result of using the set of parameters {TA, TTA} and {TA, TTA + 1}, respectively, and hereinafter referred to as “magic_mask”, “ Means to define and use a constant value called “magic_shift1” and “magic_shift”, and “maskT” Means for calculating a pseudo-random value using a D value (a value corresponding to either TA or TA + 1), using either TA or TA + 1, and a value TTA and a value calculated in advance Means for calculating a random number R using “maskT”, wherein the third means combines two one-dimensional sections of random values (u0, u1) and (v0, v1) Means for obtaining a two-dimensional interval [(u0, v0), (u1, v1)], a means for obtaining a constant called “magic_mask”, and two new numerical values, hereinafter called “maskA”. And “maskB”, means for calculating using the two random values u0 and u1, and means for calculating the random value used four times independently, comprising four sets of inputs {u0, v0, maskA}, {u0, v1, maskA}, {u1, v0, maskB}, and {u1, v1, maskB} resulting in random values R1, R2, R3, and R4 And the fifth means includes UUB and VVB. A means for obtaining from a number generator, wherein the pre-specified numerical value TTB is equal to UUB when the coordinate u is used as an input to the random number generator, and similarly, the random number generator When v is used as an input, it is a means to calculate a heavy random value that is equal to VVB and used four times independently, and includes four sets of inputs {R1, UUB, VVB}, {R2, UUB -1.0, VVB},
As a result of using {R3, UUB, VVB-1.0} and {R4, UUB-1.0, VVB-1.0}, four weight values r1, r2, r3, and r4 are obtained, and a random value RV is defined as r1, r2. , r3, r4, UUB, and VVB as inputs and a means for calculating using a bilinear interpolation module, r1,
r2, r3 and r4 are interpolated values, UUB and VVB are interpolation parameters, means for controlling bilinear interpolation operation by changing UUB and VVB, the random value RV and the input coordinates and (u, v) to obtain an output (u ′, v ′).

In a preferred embodiment of the first aspect of the present invention, in any of the above, the second means inputs either u or v coordinates (hereinafter also referred to as “t”). Two random values (u0, u1) and (v0, v1) are obtained, and two random ones are generated using two separate but similar random number generators. Here, each random number generator is a means for calculating two numerical values TA and TB from the input value “t”, where TB is a floating point value less than 1 and TA + TB is equal to 1. Means for projecting the value TB onto a random value TT, means for obtaining a constant value, hereinafter referred to as “magic_shift1”, and means for obtaining TT as a result of projecting TB into the interval [0, magic_shift1]. One having a single multiplexer and calculating TT = TB * magic_shift1, and two values TTA and TTB as the value A means for calculating from TT, wherein TTB is a floating point value less than 1 and TTA + TTB is equal to 1, and means for generating a random value, wherein the set of parameters {TA, TTA} and {TA, As a result of using TTA + 1} to generate two random values T1 and T2, respectively , means for obtaining a constant value, hereinafter referred to as “magic_shift1”, “magic_mask”, and “magic_shift2”, and the following values: That is, a means for calculating a pseudo-random value, hereinafter referred to as “maskT”, using either TTA or TTA + 1 as an input, “if statement logic circuit”, multiplexer, and logical right bit shift operator (>> ), And if the input value displayed as D and equal to either TTA or TTA + 1 is strictly lower than “magic_shift1”, calculate the following value:
maskT = magic_mask >> (TA * magic_shift2)
Otherwise, calculate the following values,
maskT = magic_mask >> ((TA + 1) * magic_shift2);
Means for calculating a random number R using as input an input value equal to either TA or TA + 1 and “maskT” as input, comprising an “if statement logic circuit”, a multiplexer, and a bit logic operator If “XOR” (represented by ^) and D is lower than “magic_shift1”, calculate the following value: R = ((1 + TTA) * magic_shift2) ^ maskT
Otherwise, calculate the next value, R = ((1) * magic_shift2) ^ maskT,
The third means combines two one-dimensional sections of random values (u0, u1) and (v0, v1) to obtain a two-dimensional section [(u0, v0), (u1, v1)]. Means for obtaining "magic_mask" and means for calculating the following two values, hereinafter referred to as "maskA" and "maskB", using the two random values u0 and u1, The calculation of mask comprises a single logical right bit shift operator, which calculates the following for the input value “t”:
(magic_mask >> t) where “t” is equal to either u0 or u1 and the resulting value “mask” is equal to either “maskA” or “maskB” respectively and is a random value. 4 sets of inputs {u0, v0, maskA}, {u0, v1, maskA},
Random values R1, R2, R3, and R4 are obtained as a result of using {u1, v0, maskB}, and {u1, v1, maskB}, and include an adder and a bit logic XOR (^) operator. And the following means for calculating each input {s, t, mask}, R = (s + t) ^ mask, and the fifth means obtains UUB and VVB from the random number generator The numerical value TTB specified in advance is equal to UUB when the coordinate u is used as the input of the random number generator, and similarly, the random number generator is used with the coordinate v as input. Is a means to calculate a weighted random value that is equal to VVB and used independently four times, and includes four sets of inputs {R1, UUB, VVB}, {R2, UUB-1.0, VVB},
As a result of using {R3, UUB, VVB-1.0}, and {R4, UUB-1.0, VVB-1.0}, four weight values r1, r2, r3, and r4 are obtained, and each module has an adder and A multiplexer is provided to calculate the next value r = R * (a + b) for each input {R, a, b}, and the random value RV to r1, r2, r3, r4, UUB, and VVB Is used as an input and is calculated using a bilinear interpolation module, r1,
r2, r3, and r4 are interpolated values, UUB and VVB are parameters for interpolation, and means for changing the UUB and VVB to control the bilinear interpolation operation. 0,1] When UUB and VVB are defined, a lookup table that maps UUB and VVB to UUB 'and VVB', and bilinear interpolation using UUB 'and VVB' as parameters for bilinear interpolation operations Means for controlling the generation of the random value, wherein the input u and v are changed in order to change the input coordinates (u, v). And a means for performing scaling, translation, and clamping operations, and comprising an adder, a multiplexer, and a clamping circuit, and means for obtaining a scaling and translation coefficient and a clamping operation type. And a means for changing the output value RV, and further comprising a means for performing a scaling operation and comprising a multiplexer, and means for obtaining a scaling factor and a clamping operation type, The fifth means is means for obtaining the output (u ′, v ′) by combining the RV and the input coordinates (u, v), and includes two adders and two “if statement logic circuits”. And independently determine u 'and v' coordinates as follows: if (u> 0)
Then u '= u + RV otherwise u' = u-RV, if (v> 0) v '= v + RV otherwise v' = v-RV, the system.

  Second aspect: Generation of 2D texture image using 1D texture image and configurable 2D to 1D mapping function

  The second aspect of the present invention is intended for first means for obtaining texture coordinates (u, v) and second means for projecting the texture coordinates (u, v) to one-dimensional texture coordinates (t). And a third means for accessing and acquiring the one-dimensional texture image stored in the memory using the one-dimensional texture coordinates (t), and a second means for generating a two-dimensional texture image using the one-dimensional texture image. And a means for generating a two-dimensional texture image. A preferred example of the second aspect of the present invention is directed to the above, wherein the second means is a means for selecting two functions G1 and G2 from a plurality of fixed functions, and any real function, hereinafter F A means for defining a reference table representing the function, and means for combining the functions G1, G2, and F.

In a preferred example of the second aspect of the present invention, in the above, the second means converts two functions G1 and G2 into {u, v, u + v, uv, u ^ 2, v ^ 2, sqrt. (u2 + v2),
Select from functions G (u, v) equal to u + v + sqrt (u2 + v2), u + v-sqrt (u2 + v2), min (u, v), max (u, v), constant} Means, “sqrt” is a mathematical function square root, x ^ 2 defines a look-up table that represents the square of x (x times x), and any real function, hereinafter referred to as F Means for combining the functions G1, G2, and F, using G1 as an input to the reference table F, thereby calculating F (G1 (u, v)), and a reference table Means for calculating a product of the output of the reference table and G2 using the output of G2 and G2 as a result to obtain a value value F (G1 (u, v)) * G2 (uv), and , And the third means uses a one-dimensional texture image F (G1 (u, v)) * G2 (uv).

The present invention can provide a new graphics circuit based on a new series of simple functions that can be easily implemented as a circuit on a graphics chip.
The present invention can provide a new graphics circuit that can reduce the cost of the memory without buffer access and with less operation than the conventional texture-related technology.
The present invention can provide a system that provides a two-dimensional texture image from a one-dimensional input texture image. If the setting is changed, the two-dimensional texture image has an interesting visual characteristic, for example, pseudo randomness. Display textures with geometric characteristics (glare, halo, motifs printed on thin fabric surfaces, etc.) as well as properties found in so-called natural textures (wood, marble, etc.), such as repeatability I can do it.

  Conventional texture units (units well known in computer graphics) usually play the following roles. Given a certain input texture coordinate (u, v), various calculations are performed to produce the output color RGBA (red, green, blue, and alpha). In RGBA, alpha generally indicates transparency. When combined, the three means described in the section “Means for Solving the Problem” form a complete texture unit. Given input 2D texture coordinates (u, v), an output color RGBA is generated. FIG. 1 shows the proposed means broken down into modules. In the first stage, the (u, v) coordinates are perturbed, resulting in (u ′, v ′). In the second stage, the two-dimensional coordinates (u, v) are mapped to the one-dimensional coordinates t, and in the final stage, the one-dimensional coordinates t are used as an index in a reference table including a one-dimensional texture image. FIG. 1 shows the disclosed invention broken down into two modules. Given input 2D texture coordinates (u, v), module 1000 (perturbation) modifies (u, v), resulting in (u ', v'), then these are 2D coordinates Is used as input to module 3000 CMap that maps to one-dimensional coordinates t. This one-dimensional coordinate is then used as an index in the one-dimensional texture lookup table in module 5000.

First aspect: Procedural one-dimensional pseudo-random pattern generation Module 1000: PERTUBATER
The first aspect of the invention relates to perturbation of input two-dimensional texture coordinates (u, v). The Pertubater module is a system for calculating a two-dimensional texture coordinate in a computer system, a first means for obtaining a two-dimensional texture coordinate (u, v), and a primary of two random values using the coordinates u and v. A second means for generating two original intervals; a third means for combining two one-dimensional intervals of the random value to generate one two-dimensional interval of four random values; and the texture coordinates (u, v) and a fourth means for generating a random value according to the two-dimensional interval of the four random values, and combining the random value and the input texture coordinates (u, v), the transformed two-dimensional And a fifth means for obtaining texture coordinates (u ′, v ′).

  The first means finds u and v. The second means obtains u and v and generates two one-dimensional sections. A third means combines two one-dimensional sections to obtain four random two-dimensional sections. The fourth means obtains a two-dimensional section value and generates a random value. The fifth means combines the random value and the input texture coordinate (u, v) to obtain a perturbed (u ′, v ′) two-dimensional texture coordinate.

In the first system, a normal bus input from any preceding module has been described. The second system is a general purpose module composed of two random number generators. In this general purpose module, the number of random number generators is used. For example, the input u is used twice and the first time, and the input v is used the second time. Four random values are generated. At this time, (u0, u1) takes u as input and (v0, u1)
v1) takes v as input. FIG. 2 shows a state in which the module 1000 Perturbater is disassembled into submodules. Hereinafter, each of these submodules will be described.

Module 1100: random1D
The random1D module is instantiated twice in module 1000. Also, the coordinates u and v are used separately. Given a certain input coordinate t, the task of this module generates two random values and a float value, which are later used in the random2D module (1200) and the random combiner module (1300), respectively. The The module responsible for generating random values is hereinafter referred to as pseudoRandomGenerator1D (this module is instantiated twice in the module random1D and the random1D module is instantiated twice, so there are a total of four instances of this module. Will do).

  The function of module pseudoRandomGenerator1D is as follows. This uses three “magic” numbers. It is sufficient to define that these numbers are simply unsigned integers and have interesting bit representations. The first magic number is referred to as “magic mask” and is an unsigned long value (32 bits). The other two are hereinafter referred to as “magic_shift1” and “magic_shift2”, which are a 4-bit value and an 8-bit value, respectively. All three magic numbers are constants. The proposed bit length is shown for illustration. Other bit lengths can be selected with significant changes to the disclosed invention. The main advantage of using these bit lengths is the miniaturization (in terms of hardware) of this module.

  First, the input parameter t (equal to u or v) is decomposed into two values, TA and TB, where TB is less than 1 and TA + TB is equal to t. The value TA is used to generate a value called maskT defined as follows:

MaskT = (magic_mask >>
((TA * magic_shift2) & 0xF)) & 0xF (1)
Where & is the bitwise AND operation, & 0xF takes into account the first 4 bits (least significant), in other words, maskT is a 4-bit value, which makes this function a very small circuit It is possible. Although written & 0xF for clarity, in the actual hardware implementation, this operation can be implicitly defined by proper circuit implementation.

On the other hand (ie, in parallel), the value TB is projected onto the interval [0, magic_shift1] using another circuit, and the result of this projection is the value TT.
TT = (TB) * magic_shift1. (2)
Similarly, the value TT is broken down into two parts, TTA and TTB, where TTB is less than 1 and TTA + TTB is equal to TT. The value TTB is used in the module randomCombiner (1300).

The value TTA is used together with a pre-calculated maskT (see equation (1)) to actually generate a random number. Next, the random value corresponding to TTA is defined as follows:
t0 = ((((1 + TTA) * magic_shift2) & 0xF) ^ MaskT) & 0xF (3)

  The output is a random number (of course, a pseudorandom number) defined as a 4-bit value. Module 1100 Random1D actually generates two random values for a given input coordinate t. This is because it is desired to map the input coordinate t to a section of the random space. The purpose of this module is to define two random values, not to define a section in the random space where t and its surrounding sections are projected. In other words, a random value should not be generated for each value of t, but rather a certain random interval should be defined for the interval adjacent to t.

When generating an interval, continuity should be considered, and if an interval [R0, R1] in random space is generated for a given input value, the next interval is [R1, R2 ] Must guarantee that it must be. As can be seen from equation (3), the value TT is the interval [0,
It is in magic_shift1]. To ensure constant continuity, special procedures should handle the case where TTA is equal to the value “magic_shift1”. If TTA is greater than or equal to the value “magic_shift1”, equations (1) and (3) are as follows:
MaskT = (magic_mask >>
(((TA + 1) * magic_shift2) & 0xF)) & 0xF (1 ')
t0 = ((((1) * magic_shift2) & 0xF) ^ MaskT) & 0xF (3 ')
As mentioned earlier, a very small bit width is sufficient.

In a preferred example of the module pseudoRandomGenerator1D, the second means inputs either u or v coordinates (hereinafter also referred to as “t”), and receives two random values (u0, u1) and (v0 , v1) is a means for generating two one-dimensional sections of two random values using two separate but similar random number generators, where each random number generator is Means for calculating two numerical values TA and TB from the input value “t”, wherein TB is a floating-point value less than 1 and TA + TB is equal to 1, and means for projecting the value TB to a random value TT Means for obtaining a constant value, hereinafter referred to as “magic_shift1“ t ”, and means for obtaining TT as a result of projecting TB into the interval [0, magic_shift1], comprising a single multiplexer. One that calculates TT = TB * magic_shift1, and one that calculates two numerical values TTA and TTB from the value TT A means for generating a random value when TTB is a floating-point value less than 1 and TTA + TTB is equal to 1, using the set of parameters {TA, TTA} and {TA, TTA + 1} As a result, two random values T1 and T2 are generated respectively , and means for obtaining constant values, hereinafter referred to as “magic_shift1”, “magic_mask”, and “magic_shift2”, and the following values, namely “maskT” Is a means for calculating using either TTA or TTA + 1 as an input, comprising an “if statement logic circuit”, a multiplexer, and a logical right bit shift operator (>>). , D and if the input value equal to either TTA or TTA + 1 is strictly lower than “magic_shift1”, calculate the following value:
maskT = magic_mask >> (TA * magic_shift2)
Otherwise, calculate the following values,
maskT = magic_mask >> ((TA + 1) * magic_shift2);
Means for calculating a random number R using as input an input value equal to either TA or TA + 1 and “maskT” as input, comprising an “if statement logic circuit”, a multiplexer, and a bit logic operator If “XOR” (represented by ^) and D is lower than “magic_shift1”, then the following value R =
((1 + TTA) * magic_shift2) ^ maskT, otherwise the next value R =
((1) * magic_shift2) ^ A maskT is calculated, and the third means includes two one-dimensional sections of random values (u0, u1) and (v0, v1). A means for combining to obtain a two-dimensional interval [(u0, v0), (u1, v1)],
A means for obtaining “magic_mask” and a means for calculating the following two values, hereinafter referred to as “maskA” and “maskB”, using the two random values u0 and u1. With one logical right bit shift operator and the following calculation for the input value “t”, mask =
(magic_mask >> t)
Here, “t” is equal to either u0 or u1, and the resulting value “mask” is equal to either “maskA” or “maskB”, respectively, and is a means for calculating a random value. 4 sets of inputs {u0, v0, maskA}, {u0, v1, maskA},
Random values R1, R2, R3, and R4 are obtained as a result of using {u1, v0, maskB}, and {u1, v1, maskB}, and include an adder and a bit logic XOR (^) operator. And calculating the following value R = (s + t) ^ mask for each input {s, t, mask}, and the fifth means obtains UUB and VVB from the random number generator The numerical value TTB specified in advance is equal to UUB when the coordinate u is used as the input of the random number generator, and similarly, the random number generator is used with the coordinate v as input. Is a means to calculate a weighted random value that is equal to VVB and used independently four times, and includes four sets of inputs {R1, UUB, VVB}, {R2, UUB-1.0, VVB},
As a result of using {R3, UUB, VVB-1.0}, and {R4, UUB-1.0, VVB-1.0}, four weight values r1, r2, r3, and r4 are obtained, and each module has an adder and A multiplexer is provided to calculate the next value r = R * (a + b) for each input {R, a, b}, and the random value RV to r1, r2, r3, r4, UUB, and VVB Is used as an input and is calculated using a bilinear interpolation module, r1,
r2, r3, and r4 are interpolated values, UUB and VVB are parameters for interpolation, and means for changing the UUB and VVB to control the bilinear interpolation operation. 0,1] When UUB and VVB are defined, a lookup table that maps UUB and VVB to UUB 'and VVB', and bilinear interpolation using UUB 'and VVB' as parameters for bilinear interpolation operations Means for controlling the generation of the random value, wherein the input u and v are changed in order to change the input coordinates (u, v). And a means for performing scaling, translation, and clamping operations, and comprising an adder, a multiplexer, and a clamping circuit, and means for obtaining a scaling and translation coefficient and a clamping operation type. And a means for changing the output value RV, and further comprising a means for performing a scaling operation and comprising a multiplexer, and means for obtaining a scaling factor and a clamping operation type, The fifth means is means for obtaining the output (u ′, v ′) by combining the RV and the input coordinates (u, v), and includes two adders and two “if statement logic circuits”. Independently, the u ′ and v ′ coordinates are determined as follows:
If (u> 0) u '= u + RV otherwise
u '= u-RV
If (v> 0) v '= v + RV otherwise
v '= v-RV.

  As shown in FIG. 2, the output of the module random1D is a random number (t0, t1) interval and a value TTB. This module is instantiated twice using u or v as input. When the input value is u, the output is a tuple (u0, u1, UUB), and when the input value is v, the output tuple is (v0, v1, VVB). Random intervals [u0, u1] and [v0, v1] are used as inputs for module 1200 (random2D), and the values UUB and VVB are used in module 1300 (randomCombiner).

Module 1200: random2D
The inputs of this module are two random value intervals [u0, u1] and [v0, v1]. It is clear that the intervals [u0, u1] and [v0, v1] are uncorrelated by the means used to generate the one-dimensional interval. The Random2D module is responsible for generating four new random values using two one-dimensional input intervals [u0, u1] and [v0, v1].

  A preferred embodiment of this circuit is to use four instances of a very small circuit, where each circuit generates a random value from a different set of input values. Hereinafter, this circuit is referred to as pseudoRandomGenerator2D.

  The random2D module first defines {u0, v0, maskA}, {u0, v1, maskA}, {u1, v0, maskB}, and {u1, v1, maskB} as four sets of inputs for this circuit. Generate what will be. The values maskA and maskB can also be represented as 4-bit values using a single logical right bit shift operation. A preferred embodiment for calculating these mask values may be any circuit that implements the following procedure:

maskA = ((magic_mask >> (u0))) &0xF;
maskB = ((magic_mask >> (u1))) &0xF;

  After calculating the values of maskA and maskB, four instances of the circuit pseudoRandomGenerator2D are transformed into a series of input parameters {u0, v0, maskA}, {u0, v1, maskA}, {u1, v0, maskB}, and {u1, v1 , maskB} is used in parallel. A preferred embodiment of this circuit consists of an adder, a bit shift and an XOR operator, and each operation is defined by a 4-bit value, resulting in a very small circuit scale.

A suitable example of the module random2D is: a means to use the constant magic_mask and two new 4-bit numbers, hereinafter referred to as maskA and maskB, calculated using two random values u0 and u1, When each mask operation consists of a single logical right bit shift operation (4 bits), the means to calculate the following value mask = (magic_mask >> t) & 0xF for the input value t, where t Is equal to u0 or u1, and the resulting 4-bit value is equal to maskA or maskB, respectively, and a 4-bit random value used four times independently, with four sets of inputs {u0, v0 , maskA}, {u0, v1, maskA},
{u1, v0, maskB}, and {u1, v1, maskB} are used to obtain 4-bit random values R1, R2, R3, and R4 as a result. A means of calculating the following value R = ((s + t) ^ mask) & 0xF for each input {s, t, mask} composed of the logical operator XOR (^), where R is 4 bits With a random value.

4-bit random value {R1, R2, R3,
R4} is used in module 1400 randomCombiner.

Module 1300: randomCombiner
The inputs of this module are random values R1, R2, R3, and R4 from module 1200 random2D and UUB and VVB from two instances of module 1100 random1D. The role of this module is to generate the final random value that is used to perturb the first input coordinate (u, v). The final random value RV generation can be broken down into two main steps.

  First, a weighting function is applied to R1, R2, R3, and R4, resulting in four new random values r1, r2, r3, and r4. A preferred embodiment of the weighting function is to use the same circuit four times with four sets of different inputs and define the weighting function as a signed distance function. The choice of this function r is important.

  In Patent Document WO 01/39126 A1, so-called gradient calculation is used instead of this function. The use of a gradient function means that for a given hash code (in other words, some random number obtained by successive substitutions using a look-up table), a certain gradient is calculated and the resulting weighting The value is to be obtained. The hash code is only used to define the gradient, ie it indicates which input values are added or subtracted, but the value of the hash code itself is not used in the actual gradient calculation. Similarly, the gradient calculation is performed four times with the circuit proposed in the cited patent document WO 01/39126 A1, resulting in four weight values.

  The purpose of randomCombiner is the same as that of gradient calculation, but the means and the meaning of the obtained value are completely different. In the present invention, the preferred embodiment of the weighting function is based on a simplified signed distance function. The first major difference is that if a circuit that calculates a signed distance function is implemented, an if statement and bit comparison are not required as in the circuit proposed in Patent Document WO 01/39126 A1. That is. Given two inputs, the signed distance is directly determined and then the signed distance value is used as a weighting value to weight each random value. In the case of a gradient function, the hash code must be decoded, the input value must be selected, and some of the selected values must be invalidated, depending on the hash code The selected values are combined (added). A measure of randomness is introduced when selecting an input value and depends on the hash code. The hash code value is not used in the final gradient calculation.

This last sentence explains one of the main differences. That is, in the present invention, the random value is a weighted value, and the weighted value is calculated as a signed distance function. A preferred embodiment for implementing a signed distance function is defined as a circuit that outputs two input values A and B, one adder, and a value A + B (hereinafter referred to as SignedDistance). To weight the four random values R1, R2, R3, and R4, the circuit SignedDistance has four sets of inputs {R1, UUB, VVB}, {R2, UUB-1.0, VVB},
Used four times in {R3, UUB, VVB-1.0}, and {R4, UUB-1.0, VVB-1.0}. In the triplet {r, a, b}, a signed distance simplified by a specific choice of a and b can be defined and can be expressed as a + b.

A preferred example of the weighting circuit is to include a weighting calculation in the SignedDistance circuit, which will be hereinafter referred to as a randomWeighting circuit. This circuit is module 1300
In randomCombiner, 4 sets of input {R1,
UUB, VVB}, {R2, UUB-1.0, VVB}, {R3, UUB, VVB-1.0}, and {R4,
Repeated 4 times with UUB-1.0, VVB-1.0}. Each instance of the randomWeighting circuit is composed of an adder and a multiplexer, and defines a new random value r = R * (a + b). .

  Note that R is a 4-bit value and a and b are two floating point values. Defining a float with 16 bits is sufficient to get good results (ie no visible unnaturalness in the final image). The value R can be converted to a floating point value, preferably in the interval [-1, 1]. Since R is a 4-bit value, this conversion is simple (only 16 possible floating point values). The proposed bit width offers a good trade-off between quality and circuit scale.

  The four randomWeighting circuits output four weighted random values r1, r2, r3, and r4. The second major step of module 1300 randomCombiner is to interpolate the weighted noise values r1, r2, r3, and r4 using bilinear interpolation. The parameters used for bilinear interpolation are derived from UUB and VVB.

  In Patent Document WO 01/39126 A1, a similar method is proposed. Bilinear interpolation is performed on the gradient using two values as parameters. For clarity, in the following comparison, let s be one of the input parameters, and let s' be the modified value of s and used for gradient interpolation. In Patent Document WO 01/39126 A1, s is associated with s ′ using a reference table. The lookup table includes a second-order polynomial function, a so-called ease curve. It is claimed that the purpose of this mapping is to increase the continuity of bilinear interpolation results. Furthermore, since the choices of the polynomial function are fixed, the table properties (the bit width of the contents and the bit width of the table entry) are fixed.

  In the invention disclosed in this document, a reference table is also used. However, since the input of the reference table is a 16-bit floating point value in the interval [0, 1] by definition, the accuracy is higher. The purpose of the lookup table in the present invention is not necessarily to increase the continuity of the result of bilinear interpolation. The objective is more comprehensive because it is important to provide a means (for the user) that controls the appearance of the resulting texture. In this sense, the reference table is defined in a circuit that can initialize the table using external data. Initialization means that someone (user) can load any precomputed function into the lookup table. By providing this possibility, the disclosed invention greatly improves flexibility and the possibility of changing settings, allowing a richer variety of texture patterns to be obtained. Examples of functions include, but are not limited to, constant functions, bias functions, gain functions, trigonometric functions, and polynomial functions.

  The aforementioned reference table converts the input parameters UUB and VVB into UUB 'and VVB'. These values are then used to perform bilinear interpolation. UUB 'linearly interpolates (r1, r2) and (r3, r4), resulting in two values, and these two values are interpolated using VVB'. The final result is a random value RV.

The last step is to perturb the initial coordinates (u, v) with a random value RV. This step is performed by the perturbed coordinate module (1500). One preferred embodiment of the present invention simply adds or subtracts RV from u and v according to the signs of u and v, respectively. The circuit defining such an example consists of two if-statement logic circuits, two negation operators, and two adders, and performs the following calculations:
If (u> 0) u '= u + RV otherwise
u '= u-RV
If (v> 0) v '= v + RV otherwise
v '= v-RV

The perturbed coordinates (u ′, v ′) are then used in module 3000.
A suitable example for controlling the generation of random values is to use a series of scaling, translation, and clamping operations. This can be broken down into two different controls, pre-control and post-control. The first control is applied to the input coordinates (u, v) before calculating the random value, but the post-control is applied to the output value RV.

  Scaling and translation operations for pre-control are implemented as adders and multiplexers in the preferred example, and for each input coordinate u and v, calculate a value collectively referred to as t as (t + translation) * scale. Here, translation and scale are some value defined elsewhere (typically by the user). In general, the resulting value is then clamped using conventional clamping operations so that the output value is in the interval [0, 1]. The clamping operation is a clamping operation well known in computer graphics, and is not included in the disclosed invention in the disclosed invention. There are several examples of clamping operations, including edge operations, repeat functions, and mirror functions.

  The post-control operation is similar to the pre-control operation, except that it is applied to the output value RV. One preferred embodiment implements the post-operation as a multiplexer that computes the value RV * scale, where scale is defined elsewhere (typically user-defined) and another value. And A similar clamping operation is performed on the resulting value to ensure that the result is within the interval [0,1].

Second aspect: Generation of two-dimensional texture image using one-dimensional texture image and settable two-dimensional to one-dimensional mapping function The second aspect of the invention disclosed in this document is the module shown in FIG. Equivalent to 3000. This module is called Coordinates Mapping, or CMap for short. As the name suggests, this module is responsible for two-dimensional input coordinates (u,
v) mapping (possibly from noise module output (u ′, v ′)) to one-dimensional texture coordinates (t).

The second aspect of the invention is basically
A first means of obtaining texture coordinates (u, v);
A second means for projecting the texture coordinates (u, v) to the one-dimensional texture coordinates (t) and a one-dimensional texture image stored in the memory are accessed and obtained using the one-dimensional texture coordinates (t). And a fourth means for generating a two-dimensional texture image using the one-dimensional texture image. The present invention is directed to a system for generating a two-dimensional texture image.

  The first means obtains u and v. The second means projects the texture coordinates (u, v) to the one-dimensional texture coordinates (t). The third means accesses and acquires the one-dimensional texture image using the one-dimensional texture coordinate (t). The fourth means generates a two-dimensional texture image using the one-dimensional texture image.

  A preferred example of the second aspect is a reference in the above system, wherein the second means represents means for selecting two functions G1 and G2 from a plurality of fixed functions, and any real function, hereinafter referred to as F. It is intended for a device comprising means for defining a table and means for combining the functions G1, G2, and F.

In a preferred example of the second aspect, in the system described above, the second means converts two functions G1 and G2 into {u, v, u + v, uv, u ^ 2, v ^ 2, sqrt ( u2 + v2),
Select from functions G (u, v) equal to u + v + sqrt (u2 + v2), u + v-sqrt (u2 + v2), min (u, v), max (u, v), constant} Means, “sqrt” is a mathematical function square root, x ^ 2 defines a look-up table that represents the square of x (x times x), and any real function, hereinafter referred to as F Means for combining the functions G1, G2, and F, using G1 as an input to the reference table F, thereby calculating F (G1 (u, v)), and a reference table Means for calculating a product of the output of the reference table and G2 using the output of G2 and G2 as a result to obtain a value value F (G1 (u, v)) * G2 (uv), and The third means is intended to use a one-dimensional texture image F (G1 (u, v)) * G2 (uv).

A suitable example of the above means is a very small circuit using a total of four adders, three multiplexers and a square root operator. The main advantage of this circuit is to define a mapping function, hereinafter referred to as Map, that associates a two-dimensional point (u, v) with a one-dimensional point t. This mapping is a composition of three functions and can generally be expressed as:
F (G1 (u, v)) * G2 (u, v), (4)
Here, G1 and G2 are selected from a series of fixed functions, and F is a reference table. A typical set of fixed functions in the preferred embodiment includes the following functions:

(Five)
G (u, v) = u (5a)
G (u, v) = v (5b)
G (u, v) = u ^ 2 (5c)
G (u, v) = v ^ 2 (5d)
G (u, v) = u ^ 2 + v ^ 2 (5e)
G (u, v) = sqrt (u ^ 2 + v ^ 2) (5f)
G (u, v) = u + v + sqrt (u ^ 2 + v ^ 2) (5g)
G (u, v) = u + v-sqrt (u ^ 2 + v ^ 2) (5h)
G (u, v) = min (u, v) (5i)
G (u, v) = max (u, v) (5j)
G (u, v) = constant (5k)

  The circuit that implements this set of fixed functions includes five adders, two multiplexers, and a square root operator. The main advantage is the diversity of choices in the lookup table and the variety of results. Of course, this diversity is much lower than a fully programmable circuit (ie, fragment shader), but in some cases it is sufficient. This is because some of the mathematical functions frequently used for context texturing in computer graphics can be represented.

  For example, equations (5e) and (5f) represent distance functions, so with an appropriate lookup table, all possible Gaussian functions and all other distance-based functions Can be realized. A series of possible functions based on the distance function can be found in the following reference materials (C. Blanc tail and C. Schlick. “Extended field functions for soft objects” Implicit Surfaces '95, Eurographics / ACM SIGGRAPH Workshop, page 21 -32, 1995).

Equations (5h)-(5i) and (5g)-(5j) define the well-known function min / max at various levels of continuity. The following reference material can be used for a more detailed explanation of the set theoretical function. (A. Pasko, V. Adzhiev, A. Sourin, and V.
Savchenko. “Functional Notation in Geometric Modeling: Concept, Implementation and Application” The Visual
Computer, 11 (8): 429-446, 1995) If you want to use only set-theoretic operations, load the identity function into the lookup table and set G2 to the constant 1. Another general function is a so-called normal function, which is expressed as u / sqrt (u ^ 2 + v ^ 2). This function corresponds to a lookup table with G1 equal to sqrt (u ^ 2 + v ^ 2), G2 equal to u, and a previously extracted function 1 / x, using the disclosed embodiment This can be obtained by selecting a reference table.

  A preferred embodiment of a circuit that implements module 3000 CMap is a set of functions expressed in equations (5a) to (5k). This is a good tradeoff between circuit scale and flexibility. Obviously, if circuit scale is not a critical issue, the flexibility can be improved by adding other fixed functions. It is also clear that the projection function can be extended with several other configurations if the hardware scale is not a major issue. For example, the proposed embodiment can be extended to F2 (F (G1 (u, v)) * G2 (u, v)) * G3 (u, v), where F2 and G3 possibilities Are two new circuits that define a new set of fixed functions or a new table.

  The final step of the disclosed invention is to calculate the index in the one-dimensional texture image using the value (t) defined in equation (4), resulting in RGBA color. Preferred embodiments of index calculation include conventional techniques in computer graphics and texture related techniques. The index calculation is not part of the claimed invention.

A straightforward extension of the invention disclosed in this document is to generate two output values t_rgb and t_a instead of a single value t. Thereby, the RGB color and the A (alpha) value can be separately indexed, and the degree of freedom can be improved. A suitable example of this extension is a means for projecting two-dimensional clamped texture coordinates (u, v) to one-dimensional texture coordinates (t), and includes four functions G1_rgb, G2_rgb, G1_a, and G2_a, The fixed function can be selected from (u, v, u + v, uv, u ^ 2, v ^ 2, sqrt (u2 + v2),
u + v + sqrt (u2 + v2), u + v-sqrt (u2 + v2), min (u, v), max (u, v)} equal to G (u, v), where sqrt is Mathematical functions square root and x ^ 2 include, but are not limited to, the square of x (x times x), with 5 adders, 2 multiplexers and 1 square root operator And two reference tables, which present all real numbers corresponding to F_rgb and F_a, and
On the one hand, G1_rgb, G2_rgb, and F_rgb are combined, and on the other hand, G1_a, G2_a, and F_a are combined. G2_rgb is calculated, the product of the reference table output and G2_rgb is calculated, and the result F_rgb (G1_rgb (u, v)) * G2_rgb
Means for obtaining (u, v) using one multiplexer, G1_a as input of the reference table F_a, thereby calculating F_a (G1_a (u, v)), G2_a Computes the product of the output and G2_a, resulting in the value F_a (G1_rgb (u, v)) * G2_a
and means for obtaining (u, v) using one multiplexer.

  Using this preferred example, only a few hardware changes, i.e. an additional lookup table, an additional multiplexer, and an extension of the means to select the input functions G1_rgb, G2_rgb, G1_a, and G2_a. Allows RGB and A to be processed separately

  The example shown in FIG. 3 is an example of an image resulting from the invention disclosed herein. Various selections of the mapping function are shown. The input geometric figure is a quadrangle, the texture coordinates (u0, v0) in the lower left corner are equal to (-1, -1), and the texture coordinates (u1, v1) in the upper right corner are equal to (1, 1) , U coordinates are along the horizontal axis in the image. A one-dimensional texture image is an array of two colors. The first color is white and the second color is black. Three images are generated using this initial setting. Only the mapping function changes. The general form of the mapping function is: Map (u, v) = F (G1 (u, v)) * G2 (u, v)

  In the first image, the fixed function G1 is defined as G1 (u, v) = u, the second fixed function G2 is defined as G2 (u, v) = 1, and the function F (reference table) is defined as F ( x) = x (identity function). Therefore, the final function is Map (u, v) = u. Recall that the texture image contains only two colors, black and white, and the predictable result is a gray gradient. If u is equal to 0, the resulting color is white; if u is equal to 1, the result is black, and in the middle, the intermediate color is gray.

  In the second image, the fixed function G1 is defined as G1 (u, v) = u ^ 2 + v ^ 2, the second fixed function G2 is defined as G2 (u, v) = u ^ 2, and the function F (reference table) is defined as F (x) = 1 / x (inverse function). The result is a gray gradient corresponding to the function u ^ 2 / (u ^ 2 / v ^ 2).

  In the last image, the fixed function G1 is defined as G1 (u, v) = sqrt (u ^ 2 + v ^ 2), the second fixed function G2 is defined as G2 (u, v) = 1, and the function F (reference table) is defined as the potential function. Note that the function G1 is the distance to the center of the quadrilateral, when the distance is equal to zero, the potential is equal to 1 and decreases to zero as the distance to the center increases, resulting in a radial A gray gradient is obtained.

The example shown in FIG. 4 is an example of an image resulting from the disclosed invention. One mapping function is selected and given various random perturbations. The input geometric figure is a quadrangle, the texture coordinates (u0, v0) in the lower left corner are equal to (-1, -1), and the texture coordinates (u1, v1) in the upper right corner are equal to (1, 1) , U coordinates are along the horizontal axis in the image. A one-dimensional texture image is an array of two colors. The first color is white and the second color is black. The same mapping function is used to generate the three images, which is as follows: Map (u, v) = u
In the first image, no perturbation is given. It can be seen that the result is similar to the first image in FIG. In the second and third images, perturbation is given, but different magnifications are set for the pre-control and post-control calculations.

  The circuit of the present invention can be applied to a three-dimensional computer graphic chip.

FIG. 1 shows the disclosed invention broken down into two modules. Given a two-dimensional input texture coordinate (u, v), module 1000 (Perturbater) transforms (u, v), resulting in (u ', v'), which in turn is module 3000 CMap And is mapped from two-dimensional coordinates to one-dimensional coordinates t. This one-dimensional coordinate is then used as an index in the one-dimensional texture reference table of module 5000. FIG. 2 shows a state where the module 1000 Perturbater is disassembled into submodules. It is broken down into two identical modules random1D, one random2D module, one randomCombiner, and finally one perturbCoordinates module. FIG. 3 shows an example of an image obtained as a result of the disclosed invention. Explains the various choices of mapping functions. FIG. 4 shows an example of an image obtained as a result of the disclosed invention. One mapping function is selected and given various perturbations.

Claims (5)

A system for calculating two-dimensional texture coordinates in a computer system,
A first means for obtaining two-dimensional texture coordinates (u, v);
A second means for generating two one-dimensional sections of two random values using the coordinates u and v;
A third means for combining two one-dimensional sections of the random value to generate one two-dimensional section of four random values;
A fourth means for generating a random value in accordance with the texture coordinates (u, v) and a two-dimensional section of the four random values;
A fifth means for combining the random value and the input texture coordinates (u, v) to obtain the transformed two-dimensional texture coordinates (u ′, v ′);
With system.
In claim 1,
The second means obtains the one-dimensional interval of two random values (u0, u1) and (v0, v1) by inputting either u or v coordinates, but is a separate but similar random number generator It has two,
A system in which the third means combines two one-dimensional sections of the random values (u0, u1) and (v0, v1) to obtain a two-dimensional section [(u0, v0), (u1, v1)].
In claim 1,
The second means is
A means for obtaining a one-dimensional section of two random values (u0, u1) and (v0, v1) by inputting either u or v coordinates (hereinafter also referred to as “t”), It has two separate but similar random number generators, where each random number generator
Means for calculating two numerical values TA and TB from the input value “t”, wherein TB is a floating-point value less than 1 and TA + TB equals 1;
Means for projecting the value TB to a random value TT;
A means for calculating two numerical values TTA and TTB from the value TT, where TTB is a floating-point value less than 1 and TTA + TTB is equal to 1,
Means for generating random values, which generate two random values T1 and T2 as a result of using the set of parameters {TA, TTA} and {TA, TTA + 1};
Comprising
The third means is
A means for obtaining two-dimensional sections [(u0, v0), (u1, v1)] by combining two one-dimensional sections of random values (u0, u1) and (v0, v1),
Means using a constant integer value, hereinafter referred to as “magic_mask”;
Means for calculating two new numerical values, hereinafter referred to as “maskA” and “maskB”, using the two random values u0 and u1;
As a result of using four sets of inputs {u0, v0, maskA}, {u0, v1, maskA}, {u1, v0, maskB}, and {u1, v1, maskB} as means for calculating random values Obtaining random values R1, R2, R3, and R4;
Equipped with
The fifth means is
A means for obtaining UUB and VVB from the random number generator, wherein the pre-specified value TTB is equal to UUB when the coordinate u is used as an input to the random number generator, and similarly, the random number If the generator is used with the coordinates v as input, it is equal to VVB;
A means for calculating a weighted random value, comprising four sets of inputs {R1, UUB, VVB}, {R2, UUB-1.0, VVB}, {R3, UUB, VVB-1.0}, and {R4, UUB-1.0 , VVB-1.0} to obtain four weights r1, r2, r3 and r4 as a result,
A means for calculating a random value RV using r1, r2, r3, r4, UUB, and VVB as inputs, comprising a bilinear interpolation module, with r1, r2, r3, and r4 interpolated Value, UUB and VVB are interpolation parameters,
With
The system is
Means for controlling the generation of the random value,
Means for changing the input coordinates (u, v);
Means for changing the output value RV;
Further comprising
The fifth means is means for combining the RV and the input coordinates (u, v) to obtain the output (u ′, v ′).
system.
In claim 1,
The system is
Means for controlling the generation of the random value,
Means for changing the input coordinates (u, v), comprising means for performing scaling, translation and clamping operations for each input u and v to obtain scaling and translation coefficients and clamping operation types; What to do,
Means for changing the output value RV, comprising means for performing scaling and translation operations to obtain a scaling factor and a clamping operation type;
Further comprising
The second means is
A means for obtaining a one-dimensional section of two random values (u0, u1) and (v0, v1) by inputting either u or v coordinates (hereinafter also referred to as “t”), It has two separate but similar random number generators, where each random number generator
Means for calculating two numerical values TA and TB from the input value “t”, wherein TB is a floating-point value less than 1 and TA + TB equals 1;
Means for projecting the value TB to a random value TT,
Means for obtaining a constant value, hereinafter referred to as magic_shift1,
Means for obtaining TT as a result of projecting TB into the interval [0, magic_shift1];
Comprising:
A means for calculating two numerical values TTA and TTB from the value TT, where TTB is a floating-point value less than 1 and TTA + TTB is equal to 1,
Means for generating random values, each of which generates two random values T1 and T2 as a result of using the set of parameters {TA, TTA} and {TA, TTA + 1}, respectively;
Means to define and use constant values called “magic_mask”, “magic_shift1” and “magic_shift2”,
Means for calculating a pseudo-random value, hereinafter referred to as “maskT”, using a D value (a value corresponding to either TA or TA + 1);
Means for calculating a random number R using either TA or TA + 1, and using the value TTA and the previously calculated value “maskT”;
Comprising:
With
The third means is
A means for obtaining two-dimensional sections [(u0, v0), (u1, v1)] by combining two one-dimensional sections of random values (u0, u1) and (v0, v1),
Means to obtain a constant called “magic_mask”,
Means for calculating two new numerical values, hereinafter referred to as “maskA” and “maskB”, using the two random values u0 and u1;
Means for calculating random values used independently four times, comprising four sets of inputs {u0, v0, maskA}, {u0, v1, maskA}, {u1, v0, maskB}, and {u1, as a result of using v1, maskB} to obtain random values R1, R2, R3, and R4;
Equipped with
The fifth means is
A means for obtaining UUB and VVB from the random number generator, wherein the pre-specified numerical value TTB is equal to UUB when the coordinate u is used as an input to the random number generator, and similarly, the random number If the generator is used with the coordinates v as input, it is equal to VVB;
A means to calculate a heavy random value that is used four times independently, with four sets of inputs {R1, UUB, VVB}, {R2, UUB-1.0, VVB}, {R3, UUB, VVB-1.0} And four weights r1, r2, r3, and r4 as a result of using {R4, UUB-1.0, VVB-1.0}, and
A means for calculating a random value RV using r1, r2, r3, r4, UUB, and VVB as inputs, and using a bilinear interpolation module, where r1, r2, r3, and r4 are interpolated values. Yes, UUB and VVB are interpolation parameters,
Means for controlling the bilinear interpolation operation by changing UUB and VVB;
Means for combining the random value RV and the input coordinates (u, v) to obtain an output (u ′, v ′);
With system.
In claim 1,
The second means is
Inputs either u or v coordinates (hereinafter sometimes referred to as “t”) to obtain two random values (u0, u1) and (v0, v1) as one-dimensional sections. Is a means for generating two one-dimensional sections of two random values using two similar random number generators, where each random number generator is
Means for calculating two numerical values TA and TB from the input value “t”, wherein TB is a floating-point value less than 1 and TA + TB equals 1;
Means for projecting the value TB to a random value TT,
Means for obtaining a constant value, hereinafter referred to as “magic_shift1”;
Means for obtaining TT as a result of projecting TB into the interval [0, magic_shift1], comprising a single multiplexer and calculating TT = TB * magic_shift1;
Comprising:
A means for calculating two numerical values TTA and TTB from the value TT, where TTB is a floating-point value less than 1 and TTA + TTB is equal to 1,
Means for generating random values, each of which generates two random values T1 and T2 as a result of using the set of parameters {TA, TTA} and {TA, TTA + 1}, respectively;
Means for obtaining constant values hereinafter referred to as “magic_shift1”, “magic_mask” and “magic_shift2”;
A means for calculating the following value, that is, a pseudo-random value, hereinafter referred to as “maskT”, using either TTA or TTA + 1 as an input, “if statement logic circuit”, multiplexer, and logical right bit shift operation Child (>>)
If the input value displayed as D and equal to either TTA or TTA + 1 is strictly lower than “magic_shift1”, calculate the following value:
maskT = magic_mask >> (TA * magic_shift2)
Otherwise, calculate the following values,
maskT = magic_mask >> ((TA + 1) * magic_shift2);
Means for calculating a random number R using as input an input value equal to either TA or TA + 1 and “maskT” as input, comprising an “if statement logic circuit”, a multiplexer, and a bit logic operator “XOR” (represented by ^)
If D is lower than “magic_shift1”, calculate the following value,
R = ((1 + TTA) * magic_shift2) ^ maskT
Otherwise, calculate the next value,
R = ((1) * magic_shift2) ^ maskT
Comprising:
With
The third means is
A means for obtaining two-dimensional sections [(u0, v0), (u1, v1)] by combining two one-dimensional sections of random values (u0, u1) and (v0, v1),
Means to get “magic_mask”,
Means for calculating the following two values, hereinafter referred to as “maskA” and “maskB”, using the two random values u0 and u1, each mask being calculated using a single logical right bit shift operator With the following calculation for the input value “t”:
mask = (magic_mask >> t)
Where “t” is equal to either u0 or u1 and the resulting value “mask“ t ”is equal to either“ maskA ”or“ maskB ”, respectively,
Means for calculating a random value, comprising four sets of inputs {u0, v0, maskA},
Random values R1, R2, R3, and R4 are obtained as a result of using {u0, v1, maskA}, {u1, v0, maskB}, and {u1, v1, maskB}, and an adder and bit logic Comprises the XOR (^) operator, calculates the following values for each input {s, t, mask};
R = (s + t) ^ mask
With
The fifth means is
A means for obtaining UUB and VVB from the random number generator, wherein the pre-specified numerical value TTB is equal to UUB when the coordinate u is used as an input to the random number generator, and similarly, the random number If the generator is used with the coordinates v as input, it is equal to VVB;
A means of calculating a weighted random value that is used four times independently, comprising four sets of inputs {R1, UUB, VVB}, {R2, UUB-1.0, VVB}, {R3, UUB, VVB-1.0} , And {R4, UUB-1.0, VVB-1.0} resulting in four weights r1, r2, r3, and r4, each module having an adder and multiplexer, and each input {R , a, b} to calculate the following values,
r = R * (a + b)
Random value RV, r1, r2, r3, r4,
Means to calculate using UUB and VVB as input and bilinear interpolation module, where r1, r2, r3, and r4 are interpolated values, and UUB and VVB are interpolation parameters Because
A means for controlling the bilinear interpolation operation by changing UUB and VVB,
A reference table that maps UUB and VVB to UUB ′ and VVB ′ when UUB and VVB are defined in section [0, 1];
Means for calculating bilinear interpolation using UUB 'and VVB' as parameters for bilinear interpolation operation;
Equipped with,
With
The system is
Means for controlling the generation of the random value,
In order to change the input coordinates (u, v), each input u and v is subjected to scaling, translation, and clamping operations, and is composed of an adder, a multiplexer, and a clamping circuit, and scaling. And means for obtaining a translation coefficient and a clamping operation type, and means for changing the output value RV, which performs a scaling operation and is configured by a multiplexer, and a scaling coefficient and a clamping operation A means for obtaining a type;
Further comprising
The fifth means is means for combining the RV and the input coordinates (u, v) to obtain an output (u ′, v ′);
With two adders and two “if statement logic”, independently determine the u ′ and v ′ coordinates as follows:
If (u> 0) then u '= u + RV otherwise
u '= u-RV
If (v> 0) then v '= v + RV otherwise
v '= v-RV
system.

Images