INCREMENTAL INTERLACE INTERPOLATION FOR TEXTURE MORPHING

Abstract: A fast, texture morphing algorithm for real-time computer simulation and video games dynamically generates objects "on the fly" by simplifying and reducing the computational load required for a texture morphing/blending process. Incremental interpolation techniques compute a morh parameter based on previous value and morph change rate. Precomputed initial and incremental morph parameter values for each texel component are applied during real-time morphing procedures using integer arithmetic. Approximation errors are reduced by incrementing/decrementing by an extra integer value when the number of morph iterations is a multiple of a frame counter. The frame counter avoids over-runs, and the morphing procedure is "snapped" the texel value to the precise texture target value to prevent under-runs and corresponding artifacts. Interlacing (applying interpolation to a subset of the texels each frame) significantly reduces computational load without introducing significant image artifacts. The morph texture buffer data structure is initially decomposed off-line to reduce the number of real-time calculations required to manipulate texel component data.

Description: INCREMENTAL INTE ' SLACE INTERPOLATION FOR TEXTURE MO PHING FIELD OF THE INVENTION This invention relates to computer graphics, and more particularly, to techniques for metamorphosing ("morphing") a texture map from a source texture to a tarset texture. BACKGROUND AND SUMMARY OF THE INVENTION In graphics, metamorphosis, or morphing, is the process of gradually changing a source object through intermediate objects into a target object. For example, a person's face can be morphed into another person's face, an animal can be morphed into a human, etc. Morphing can create striking special effects, and has numerous applications -- from modeling, computer simulation and video games to generation of animation sequences for the movie and advertising industries. Past advancements in 3D morphing have tended to concentrate on developing algorithms for morphing geometry between source and target objects. However, modem 3D graphics commonly uses texture mapping to make 3D objects more interesting and apparently more complex. Generally, texture mapping involves taking a 2D image (e.g., a photographic or other digitized picture) and placing it onto a 3D surface. As one example, a brick wall can be imaged by mapping a brick-and-mortar texture onto a simple rectangular surface of a 3D "wall" object. Images of foliage, clouds, and a variety of other complex images can all be created using such texture mapping techniques. When attempting to morph a textured 3D image, one must morph the texture as well as the geometry. Texture maps can be large, and each texel in the map should be morphed to provide a range of interpolated texture values between .ource and target textures. Such texture morphing therefore tends to be computationally expensive — effectively preventing resource-constrained real-time graphics systems such as home video game systems and personal computer graphics cards from providing real-time texture morphing functionality. What is needed is a texture morphing procedure that is fast and efficient enough to be performed in real-time within limited resource environments so that texture morphing can be performed "on the fly" in a limited resource graphics system. The present invention provides a solution to this problem by providing a fast. real-time texture morphing algorithm that is both fast and efficient. The preferred embodiment of the invention provides a number of efficiencies to simplify and reduce the computations required within a texture morphing/blending process. such techniques including off-line texel component decomposition; incremental interpolation: frame counters; interlace morphing; and background low-priority threading. These techniques can be used individually and/or in combination to provide morphing procedures fast enough for real-time computer animation and simulation and video games. In accordance with one aspect of the present invention, incremental interpolation techniques are used to reduce repetitive and heavy floating point number calculations/conversions associated with the typical texel blending/morphing process. The preferred embodiment computes an incremental morph parameter t for each texel component based on previous value and change rate (e.g.. image frame rate and the time duration of the morphing process). Initial and incremental morph parameter values can be computed in advance for each texel component during a preliminary morph preparation background process. Then, during a subsequent real-time morphing process, these initial and incremental parameter values are applied incrementally to moφh the texel components toward target texel component values. To save floating-to- fixed point conversion time, the preferred embodiment uses integer addition to apply the incremental moφh parameter values to the texel component values. However, to preserve accuracy, incremental and new values should be floating point numbers. The preferred embodiment resolves this inconsistency by using a frame counter concept. The moφh parameter preparation process determines, for each texel component value, how many image frames it will take for a fractional portion of the incremental parameter value to change the integer portion of the texel component value. The preferred embodiment carefully chooses the resulting frame counter values to prevent overruns, and uses them to specify when additional integer correction factors should be applied during the incremental inteφolation process. To avoid image artifacts due to mismatch between the moφhed texel component values and the actual target texel values, the preferred embodiment "snaps" the texel values to the precise (floating point) target values during the last moφh iteration. In accordance with another aspect of the invention, incremental inteφolation can be applied each frame time or other moφhing period to less than all of texels being moφhed. For example, some texels can be incrementally inteφolated during a particular frame, other texels can be incrementally inteφolated during a subsequent frame, etc . -- so that all texels are incrementally inteφolated across a certain (preferably small) number of frames without requiring each texel to be inteφolated every frame. Such interlacing of incremental inteφolation can significantly reduce computational load without introducing significant image artifacts. In accordance with yet another aspect of the invention, the texture buffer data structure is initially decomp osed off-line to reduce the number of real-time operations required to separate and manipulate texel component data for moφhing. The preferred embodiment decomposes the standard texture map into separate arrays for each of the colors (RGB) and for alpha (transparency). The resulting component arrays (which may be 8-bit integer arrays, for example) can be manipulated directly by real-time software without additional masking/data extraction overhead. One significant and advantageous application of the present invention is to allow dynamic generation of a virtually infinite number of video game characters and other textured objects "on the fly " using moφhing procedures within home video game systems, personal computer graphics cards, and other inexpensive graphics systems. It is possible to pre-construct a number of objects with certain geometry and textures as primary sources and targets (" moφh terminals"), and then use the texture moφhing features provided by this invention to smoothly transform textures in real time between such objects to generate a sequence of continuous intermediate objects along moφhing paths between the moφh terminals. Since the preferred embodiment stores each set of intermediate moφhed texture values as a texture map, any such intermediate texture map can be used as a source texture map for a further texture moφhing operation along the same or different moφh path. BRIEF DESCRIPTION OF THE DRAWINGS These and other features and advantages provided by the present invention will be better and more completely understood by referring to the following detailed description of preferred embodiments in conjunction with the drawings of which: Figure 1 shows an overall example 3D graphics system; Figure 2 shows an example virtual object moφhing space; Figure 3 is a flowchart of an example overall texture moφhing process provided by the present invention; Figure 3A shows an example graphics system storage device that stores information to control the Figure 1 graphics system to perform the steps shown in Figure 3; Figure 4 shows example off-line decomposition of a texture map into separate component arrays; Figures 5 & 5A-5D illustrate an example incremental moφhing process; Figure 6 shows an example interlacing example; and Figure 7 is a flowchart of example steps the preferred embodiment performs to provide incremental interlaced texture moφhing. DETAILED DESCRIPTION OF PRESENTLY PREFERRED EXAMPLE EMBODIMENTS Figure 1 shows an example real time 3-D computer graphics display system 50 that may be used to provide realistic interactive real time 3D moφhing in accordance with the present invention. The Figure 1 example system 50 includes a NINTENDO 64® 3-D video game console 52 and associated hand controllers 54a, 54b. A cartridge 56, optical disk or other storage medium storing a software animation (video game) program is operatively connected to console 52. The console 52 is connected to a display device 58 such as a conventional home color television set or computer monitor. Console 52 includes a 3D graphics engine that can render 3D animation on display 58 in real time response to user manipulation of controllers 54a, 54b. The software within cartridge 56 controls console 52 to display a sequence of animated video frames on display 58. Human players may operate hand controllers 54a, 54b to cause, under control of software within game 5 cartridge 56. game characters to moφh interactively in real time. Figure 2 shows an example of how intermediate moφh objects can be dynamically created between three moφh terminals 10, 12, 14 using the Figure 1 system. The objects in circles (obj 1 , obj2 and obj3) are intermediate moφh objects. In this particular Figure 2 example, moφhing terminals 10. 12 and 14 10 comprise a dog, a human and a vehicle, respectively. In this example, any moφhing terminal 10, 12, 14 can be moφhed into any other moφhing terminal along moφhing paths 16. For example, dog moφh terminal 10 can be moφhed into human moφh terminal 12 (or vice versa) along moφhing path 16a; human moφh terminal 12 can be moφhed into vehicle moφh terminal 14 (or vice versa) I D along moφh path 16b; and dog moφh terminal 10 can be moφhed into vehicle moφh terminal 14 (or vice versa) along moφh path 16c. In this example, the moφh procedure can be stopped at any point during the procedure (not necessarily at the source or the target), and the intermediate object at that point can be used as a new game character with an "in-between" shape and 0 color. This new object (for example, object "Obj 1 " — a moφh hybrid of a dog and a human) could be used as a source for yet another moφh procedure to further moφh the object into a further moφh "Obj2" -- and so on. More generally, the moφh terminals 10, 12, 14 define a virtual object space VOS. Any point inside the space VOS represents an intermediate object hich 5 could be rendered as any other pre-constructed object s) in the simulations. Such an ability has the potential of stunning game players by its versatility and unpredictability ~ producing hit video game titles that are interesting and enjoyable to play. Texture Morphing Those skilled in the art understand that there already exist a number of efficient algorithms for moφhing geometrical data of 3D objects. See, for example, Chen et al, "Interactive Shape Metamoφhosis", 1995 Symposium on Interactive 3D Graphics pp. 43-44 (ACM SIGGRAPH April 1995). However, when moφhing between the source and target 3D objects, not only the geometry (vertices and polygons) of the object, but also the color and texture of the object must be transformed from "source form" to "target form". Texture moφhing has. in the past, typically been performed using a computationally intensive brute-force heuristic color blending approach. A Heuristic Approach For example, assume a conventional RGB A 32-bit texture map format and further assume that the current moφh source, target and intermediate textures are stored in array sourceTexture[], targetTexture[] and mediateBuffer[] respectively . The brute-force heuristic solution for blending (inteφolating) texture components can be described by the following pseudo-code for performing a general floatingpoint inteφolation function to inteφolate between source and target texture maps: for(each texel in each texture tile) { // decompose source and target texels into R. G.B.A components; sourceRed = (sourceTexturefk] & OxjfOOOOOO) » 24; sourceGrn = (sourceTexturefk] & OxOOffOOOO) » 16; sourceBlu = (sourceTexturefk] & OxOOOOffOO) » 8; sourceAlp = (sourceTexturefk] & OxOOOOOOjf) . targetRed = (targe tTexturefk] & OxjfOOOOOO) » 24, targetGrn = (targe tTexturefk] & OxOOffOOOO) » 16; targetBlu = (target! zxturefk] & OxOOOOffDO) » 8; tar get Alp = (target! xturefk] & OxOOOOOOjf); // interpolate the cohr components newRed = (1-t) * sourceRed + t * targetRed; newGrn = (1-t) * sour:eGrn + t * targetG n; newBlu = (1-t) * sourceBlu + t * targetBlu; newAlp = (1-t) * sourceAlp + t * targetAlp; //Assemble the new texel from new components; mediateBufferfk] - (newRed«24) \ (newGrn< < 16)\ (newBhK <8) \ new Alp; where 0.0 <= t <= 1.0 is the moφh parameter (i.e.. the position of the current moφh along a moφh path 16). Those skilled in the art will understand that such a brute-force heuristic approach is straightforward to implement but very computationally expensive — and is therefore not really feasible for real-time interactive limited resource computation environments such as 3D home video game systems. A New Texture Morphing Process Provided by the Present Invention Figure 3 is a flowchart of an overall process provided by a presently preferred example process 100 of the invention. Process 100 is divided into two overall stages: an authoring stage 102, and a run-time stage 104. During authoring stage 102, process 100 performs a step 106 that decomposes texel color information to be moφhed into separate RGBA component arrays. These separate arrays can be handled at run-time more efficiently than could a typical unified RGBA texel array. In the preferred embodiment, the separate RGBA arrays are stored in cartridge 56. from which they can be efficiently read out and copied into the read/write memory of system 52 for efficient manipulation. During run-time stage 104 (which may, in the preferred embodiment, be performed in real time response to interactive inputs provided by user-operated controls 54), the preferred embodiment defines initial and incremental moφhing parameters for the texels to be moφhed (block 108). This moφhing parameter definition step may be performed once per source/target change as a background task some time in advance of when moφhing must begin (block 108). Then, during a run-time moφhing step (block 1 10), the preferred embodiment applies the incremental moφhing parameters to the RGBA texel arrays using integer addition to provide incremental inteφolation in an interlaced fashion — avoiding under-runs by "snapping" the texel values to exact target values when ( if) the moφh target is reached. Figure 3A shows the Figure 1 cartridge 56 or other storage medium storing software code 56a (e.g., in a read only memory) controlling system 50 to perform the Figure 3 texture moφhing process. In this example, storage device 56 stores, among other things: • conventional texture mapping software instructions 56- 1 , • instructions for implementing texel morph precompute step 108. • instructions for implementing texel moφh compute step 1 0; • separate texture component arrays as shown in Figure 4; • conventional instructions for controlling system 50 to interactively respond to user inputs via controllers 54; and • conventional instructions for controlling system 50 to display 3D textured objects. Off-line color decomposition: Figure 4 details an example off-line color decomposition step 106. To eliminate texel decomposition and new texel assembly at run-time, the preferred embodiment reserves and loads one 32-bit texture map block in the static display list (i.e. textureBuffer[]) for the intermediate object. Instead of using one 32-bit array 120 (a conventional form for texture maps), the preferred embodiment decomposes the RGBA texels components of texture map 120 off-line and uses resulting separate texel component arrays (e.g., 8-bit arrays 122R, 122G, 122B and 122A for the red, green, blue and alpha texel components, respectively) to store the texel components. As compared to the heuristic approach discussed above, the code that extracts the individual RGBA values from the 32-bit texel map can be eliminated, leaving the only the code for color inteφolation left in the "for" loop as: for(each texel in each texture tile) { unsigned char *texel = &textureBujferfk]; texel [RED] = (1-t) * sourceRedfk] + t * tar get Red [k]; texel [GRN] = (1-t) * sourceGrnfk] + t * targetGrnfk] ; texel [BL U] = (1-t) * sourceBlufk] + t * targetBlu [k]; texel f ALP] = (1-t) * sourceAlpfk] + t * targetAIpfk], However, the preferred embodiment does not use this form of inteφolation, but instead uses a faster incremental inteφoiation process discussed below. Incremental interpolation: To reduce repetitive and heavy floating point number calculations, consider how the red component is computed (inteφolated) for a particular texel: r = ( 1 -t) * SR + t * TR (E. l ) where r is the new red component, SR and TR are source and target red components respectively, and t is a real number that changes along the moφhing procedure from 0.0 through 1.0. If the frame rate (FR) is a constant (say, 30 frames per second), and the number of seconds (S) within which the moφhing has to finish is given, then the rate of change oft, represented by Δt, is obtained by Δt=l/(FR*S) (E.2) In other words, the value oft can be pre-computed incrementally based on its value in the previous time slot and its change rate, i.e. t'=t + Δt. (E.3) Inserting (E.3) to (E.l) to compute r' (the red component value for the frame next to r), we have r' =(l-t')*SR + t'*TR (E.4) = (l-t-Δt)* SR + (t+Δt)*TR = (T-0 * SR + t * TR + Δt * (TR-SR) =r + Δr where from (E.2) Δr = Δt * (TR-SR) = (TR-SR) / (FR * S) involves only constants (so long as the frame rate is constant) and thus can be pre- computed as a uniform increment only once in advance before the morph process starts. (E.4) states that the texel components can be inteφolated through incremental addition (i.e., repeatedly adding or subtracting the same uniform constant value over and over again), including only one addition (subtraction) operation. See Figure 5. Notice that from (E.l) we have r = SR' n This gives the initial condition of equation (E.4). With this in mind, when given a source and target, the preferred embodiment divides the moφh procedure into two phases: Moφhing preparation (Figure 3, block 108) is done only once per source/target change. This is where the moφh parameters (initial and incremental values for each texel) are computed. The following is example pseudo-code for such a computation: numberOjFrames - frameRate * numberOjSeconds ; for(each texel in each texture tile) { redDltfk] = (targetRedfk] - sourceRedfk]) / numberOjFrames ; grnDltfk] = (targetGrnfk] - sourceGrnfk]) / numberOjFrames; bluDltfk] = (targetBlufk] - sourceBlufk]) / numberOjFrames; alpDltfk] — itargεtAlpfk] - sourcsAlpfk]) / numberOjFrames; newRedfk] - sourceRedfk]; newGrnfk] = sourceGrnfk]; new Blu fk] = sourceBlufk]; new Alp [k] = sourceAlpfk]; } Moφhing process (Figure 3, block 1 10) is performed each iteration to change the value of color components for each texel when the moφhing is in progress. In the preferred embodiment, only addition operations are used in this step. The following is example pseudo-code: I : forfeach texel in each texture tile) { newRedfk] += redDltfk]; newGrnfk] += grnDltfk]; newBlufk] + = BluDltfk]; new A Ipfk] += A IpDltfk]; unsigned char *texel = &textureBujferfk]; texelfRED] = newRedfk]; texel fGRN] = newGrnfk]; texel [BL U] = newBlufk]; texel f ALP] = newAlpfkJ; A problem with the example moφhing procedure described above relates to its use of integer addition. In order to preserve the accuracy, incremental and new- values (i.e. redD ' :[], newRedf], etc.) should be floating point numbers. However, the 32-bit RGBA texture format defines components ( i.e. texelfRED], texel[GR ], texel[BLU] and texel[ALP]) to be 8-bit integers. Thus the last four assignment statements in the loop body above imply costly data type conversions. Hence, use of integer arithmetic to eliminate floating-point conversions for each incremental inteφolation can (depending on the particular platform) significantly speed up the moφhing calculations, but may also result in a loss of accuracy as compared to the use of floating point arithmetic — since the intermediate moφh values will be only integer approximations of the actual value, that would be obtained using floating point inteφolation techniques. See Figure 5A. To eliminate this hidden cost, the preferred embodiment uses a non-uniform integer correction factor — i.e, it adds an additional integer correction factor (e.g., + 1 or - 1 ) during some but not all moφhing steps — with a frame counter selecting when the correction factor should be added. When preparing moφh parameters, the preferred embodiment separates the integer part and decimal part of the color delta values ( see Figure 5B). and computes the number of frames (i.e. redCntf]) required for the decimal (fractional) part to add up to 1. For instance, if the decimal part of the delta value is 0.2, then the value of its frame counter should be 5. The following is example pseudo-code: for/each texel in each texture tile) { delta = (targetRedfk] - sourceRedfk]) / numberOjFrames; redlntfk] = floor (delta); decimal = delta - redlntfk]; redCntfk] = (1.0 / decimal) + 0.5; // do the same to green, blue and alpha components ; } When moφhing texels, the preferred embodiment adds the integer part of an incremental value to a texel component in each iteration ~ and adds an extra 1 to the value only when the number of iterations is a multiple of X, where N is specified by its frame counter . See Figure 5. Such further incrementing by a non- uniform amount corrects for approximation errors. Notice that all arithmetic operations in the iteration involve only 8-bit integers. The following is example pseudo-code: // compute the multiples of current frame numbers. for(i-l; i< numberOfFrames; i÷+) { frames [i] = (currentFrame%i) ? 0: 1; } cιιrrentFrame++; II morph texels for(each texel in each texture tile) { !EXEL_!YPE *texel = S textureBufferfk]; texel [RED] += (frames [redCntfk]])? (redlntfk] + 1); redlntfk]: texel [GRN] + = (frames [grnCnt[k]])1 > (grnlntfk]÷ l : grnlntfk]; texel [BL U] += (frames [bluCntfk]])? (bhdntfkj÷ lj: blulntfk]: texel f ALP] + = (frames falpCntfk]]) ? (alplnt[k]+ 1): alplntfk]; i J The use of frame counters provides significant improvement in calculation speed, but also introduces a potential inaccuracy. Since it is not guaranteed that the decimal part of an incremental value can always be added up to exactly 1.0, the procedure is prone to "over-run" or "under-run" in certain circumstances, depending on how the value of a frame counter is calculated. For example, when approaching the end of moφhing procedure, the texel values of an intermediate moφh object may exceed that of the target object and create disturbing artifacts. To overcome this over-run problem, the preferred embodiment carefully chooses frame counters values so they never lead to an "over-run" situation. In one simple illustration, the frame counter values are rounded down instead of up to ensure that the incremental inteφolation process yields texel values that do not exceed the values they would take on if floating point arithmetic were used.. To solve the resulting "under-run" situation, the texel values of the intermediate moφh object is "snapped" to that of the target object by using a floating-point operation at the last increment ~ making the now fully moφhed texel values become precisely equal to the target object texel values. See Figure 5D. The results provided by the preferred embodiment become an approximation to those supplied by the heuristic solution after this step. Interlace morphing: To further speed up the moφhing process, the preferred embodiment defines INTERLACE to be a positive constant integer. When preparing the moφh parameters, the preferred embodiment multiplies the integer parts of incremental values of components by this constant. When moφhing textures, the preferred embodiment updates the values of texels at a regular intervals specified by INTERLACE. For example, if INTERLACE=3, then the preferred embodiment modifies texels 0, 3, 6, ... in the first iteration, modifies texels 1 , 4, 7, ... in the second, do 2, 5, 8, ... in the next, and so forth. Here is example pseudo-code: for(i=l; i<numOfFrames; i÷+) { frames fi] = (currentFrame%i)? 0: 1; } for(k=interlace; k<TOTAL__TEXELS; k+=IN!ERLACE) TEXEL _TYPE *texel = &textureBujfer[k]; " texel [RED] += (frames [redCnt[kf]) (redlntfk] + INTERLACE): redlntfk]: texel [GRN] += (frames [grnCntfk]]) ? (grnlnt[k]+ INTERLACE): grnlntfk]: texel [BLU] + = (frame [bluCntfk]])? (blulntfk]+ INTERLACE): blulntfk]; texel [ALP] + = (frames falpCntfk]]) (alplntfkj INTERLACE): alplntfk]; interlace = (++ interlace) % INTERLACE; if (.'interlace) currentFrame+ + ; Figure 6 shows this example interlacing graphically, with one subset of texels 600a being incrementally inteφolated every first of three successive frame times, a second subset of texels 600b being updated every second of three successive frame times, and a third subset of texels 600c being updated every third one of three successive frame times. The Figure 6 interlacing moφhs all texels every three frames, but only needs to moφh 1/3 of the texels each frame — thus significantly reducing computational load. Interlace factors other than 3 (e.g.. 2, 4, etc.) can be used. Use of Background low-priority thread: Although the actually moφhing procedure described above may run at a satisfactory speed, the procedure of preparing the moφh parameters (i.e. incremental values and frame counters) is still computationally expensive. In some circumstances, depending on the number of texels in texture tiles to be inteφolated, it can introduce noticeable delays. To avoid this visual anomaly, the moφh parameter preparation stage can be sprouted as a task with a lower priority running at the background. In the preferred embodiment, the moφhing procedure starts only after receiving a signal from this background task upon its completion. This effectively eliminates the frame rate interruptions. Example Overall Texture Morphing Process Figure 7 is a flowchart of example run-time steps performed by the preferred embodiment of this invention. In the preferred embodiment, the process 300 shown in Figure 7 is performed based on software instructions stored within cartridge 56. In this example, the Figure 7 moφh process 300 begins in response to user commands inputted through controls 54 and/or other code stored within cartridge 56 (block 306). Such an event causes a main thread 302 to begin executing. Main thread, in turn, dynamically sprouts a background thread 304 (block 308) to perform certain computationally intensive tasks in advance of a real-time moφhing phase of the process. For example, background thread 304 (which may be passed the source and target texture maps as well as parameters relating to a constant frame rate and the duration of moφhing) computes certain initial and incremental moφh parameter values for each texel component within the texture map to be moφhed (block 310). In this example process 300, for each texel, background thread 304 computes an incremental integer and a frame counter value, multiplies the incremental value by an interlace factor, and checks to make sure there are no overruns (block 310). Meanwhile, main thread 302 performs other computational duties (block 3 12) and waits until background thread 304 is finished calculating the moφh parameters (decision block 314). Once background thread 304 is ready and has completed its calculation tasks ("yes" exit to decision block 314), main thread 302 repetitively performs a moφh processing loop comprising blocks 316-322. Within this processing loop (which may be performed each imaging frame, i.e., thirty times per second), main thread 302 inteφolates each texel component within the texture map by adding the uniform incremental value for each component (as conditioned on an interlace factor), and may add a non-uniform value (e.g., plus or minus one) in certain frames to compensate for approximation errors resulting from the integer arithmetic (block 318). An interlace counter is incremented to keep track of the interlacing factor vis a vis the current frame, and the interlacing factor may be used to select which subset of texels to inteφolate during a given frame (block 322). This same calculation may be repeated for each frame until the last moφhed framed approaching the target texture (as tested for by decision block 320). Upon reaching the last moφhed frame ("yes" exit to decision block 320), process 300 "snaps" the texel component values to the actual target texture values (block 324) — thus avoiding noticeable image artifacts resulting from the integer approximation calculations performed by block 3 18). While the invention has been described in connection with what is presently considered to be the most practical and preferred embodiment, it is to be understood that the invention is not to be limited to the disclosed embodiment. For example, although the invention has been described in the context of a 3D texture moφhing system, it can also find utility in the context of 2D image moφhing, waφing and/or blending. The invention is intended to cover various modifications and equivalent arrangements included within the scope of the appended claims.

Claims: WE CLAIM: 1. A process for moφhing a texture comprising: determining an incremental moφh parameter corresponding to a texel component, and in response to said incremental moφh parameter, incrementally inteφolating said texel component toward a target texel component state through at least one intermediate moφh texel component state. 2. A process as in claim 1 wherein said incrementally inteφolating step comprises repetitively adding said incremental moφh parameter to said texel component to produce a corresponding sequence of intermediate moφh texel component states. 3. A process as in claim 1 wherein said incrementally inteφolating step comprises using an integer arithmetic calculation to repetitively increment or decrement said plural texel component based on said determined incremental moφh parameter. 4. A process as in claim 1 wherein said determining step calculates said incremental moφh parameter as the amount of change in said texel component for each successive time period within a moφhing procedure, and said incrementally inteφolating step changes said texel component in response to the integer portion of said incremental moφh parameter. 5. A process as in claim 4 wherein said successive time periods comprise image frame times. 1 6. A process as in claim 4 wherein said incrementally inteφolating step ° conditions said change in said texel component based on which of said successive 3 time periods has occurred within said moφhing procedure to reduce the number of 4 calculations required to moφh said textured surface. 1 7. A process as in claim 4 further including selectively adding 1 to or subtracting 1 from said integer portion to reduce approximation errors in the context of integer arithmetic operations. 1 8. A process as in claim 1 wherein said incremental inteφolation step comprises incrementing or decrementing said texel component by integer approximations of said determined moφh parameter, and compensating for approximation errors by performing at least one floating point operation to set said texel component to a target texel component value. 9. A process as in claim 1 wherein said incremental inteφolation step selectively inteφolates said texel component based on an interlace factor. 10. A process as in claim 1 further including conditioning said incremental inteφolation step based on an interlace factor. 1 1. A process as in claim 1 further including calculating a frame counter corresponding to said texel component, and selectively incrementing or decrementing said texel component in response to said frame counter. 12. A process as in claim 1 further including the preliminary step of storing said texel component in a separate texel component array. 13. A process as in claim 12 wherein said texel component comprises one of a red, green or blue color value and an alpha value. 14. A system for moφhing a textured surface comprising: a determiner that determines an incremental moφh parameter corresponding to a texel component, and an incremental inteφolator that incrementally inteφolates, in response to said incremental moφh parameter, said texel component toward a target texel component state through at least one intermediate moφh texel component state. 15. A system as in claim 14 wherein said incremental inteφolator repetitively adds said incremental moφh parameter to the texel component to produce a corresponding sequence of intermediate moφh texel component states. 16. A system as in claim 14 wherein said incremental inteφolator comprises an arithmetic calculator that performs a repetitive integer arithmetic calculation to repetitively increment or decrement said plural texel component based on said determined incremental moφh parameter. 17. A system as in claim 14 wherein said incremental inteφolator calculates said incremental moφh parameter as the amount of change in said texel component for each successive time period within a moφhing procedure, and changes said texel component in response to the integer portion of said incremental moφh parameter. 18. A system as in claim 17 wherein said successive time periods comprise image frame times. 19. A system as in claim 17 wherein said incremental inteφolator conditions said change in said texel component based on which of said successive time periods has occurred within said moφhing procedure to as to reduce the number of calculations required to moφh said textured surface. 20. A system as in claim 17 further including an adder that selectively adds or subtracts 1 relative to said integer portion to reduce approximation errors in the context of integer arithmetic operations. 21. A system as in claim 14 wherein said incremental inteφolator increments or decrements said texel component by integer approximations of said determined moφh parameter, and compensates for approximation errors by performing at least one floating point operation to set said texel component to a target texel component value. 22. A system as in claim 14 wherein said incremental inteφolator selectively inteφolates said texel component based on an interlace factor. 23. A system as in claim 14 further including a conditioner that conditions said incremental inteφolation step based on an interlace factor. 24. A system as in claim 14 further including a frame counter corresponding to said texel component, and wherein said incremental inteφolator selectively increments or decrements said texel component in response to said frame counter. 25. A system as in claim 14 further including a separate array storing said texel component arrays. 26. A system as in claim 25 wherein said texel component comprises one of a red, green or blue color value and an alpha value. 27. An efficient 3D moφhing process for moφhing 3D textured objects displayed using a real time interactive 3D graphics system including user- manipulable controls, said system displaying at least one 3D object based at least in part on a texture map comprising plural texels each comprising plural texel components, said 3D moφhing process including: (a) calculating incremental moφh parameter values for texels of said texture map; and (b) in real time, incrementally changing the value of said plural texel components over time based on said calculated incremental moφh parameter values. 28. A process as in claim 27 wherein said calculating step (a) comprises :alculating the value of Δr = (TC-SC) / (FR * T), where SC is the source texel component value, SC is the target texel component value, FR is the frame rate and T is the moφhing duration. 29. A process as in claim 28 wherein said incrementally changing step comprises repetitively incrementing or decrementing said plural texel component values by uniform amounts at a first predetermined frequency based on the integer portion of Δr, and adding or subtracting a further integer value at a further predetermined frequency less than said first predetermined frequency. 30. A process as in claim 29 wherein said first and second predetermined frequencies are each based on image frame rate. 3 1. A process as in claim 29 wherein said second predetermined frequency is based on a frame counter t lat counts a predetermined number of image frames. 32. An efficient 3D mDφhing process for moφhing 3D textured objects displayed using a real time interactive 3D graphics system including user- manipulable controls, said system displaying at least one 3D object based at least in part on a texture map comprising plural texels each comprising plural texel components, said 3D moφhing process including: (a) calculating incremental moφh parameter values for said texel components, including rounding down calculated incremental inteφolation values to the closest integer values to provide integer results and calculating period counter values based on non-integer remainders of said calculated incremental inteφolation values; (b) at least in partial response to user interaction with said controls, changing texel component values at a first periodic frequency based on said integer results; and (c) at least in partial response to said period counter, further changing said texel component values at a second periodic frequency less than said first periodic frequency to compensate for approximation errors introduced step (b). 33. In a real-time interactive graphics system including at least one user- manipulable control, a process for generating animation objects in real time by moφhing a source texture map including plural texels each having plural components, into a target texture map including plural texels each having plural components, said process comprising: (a) calculating incremental moφh parameter values for texels of said first texture map, and incrementally inteφolating the value of said plural texel components of said first texture map over time based on said calculated uniform incremental moφh parameter values so as to moφh said first texture map toward said second texture map; (b) using an intermediate texture map generated by step (a) to texture map an animation object; and (c) controlling at least one of the displayed orientation and position of said texture-mapped animation object at least in part in response to user manipulation of said control. 34. A storage device for use with a real-time interactive graphics system including at least one user-manipulable control, said storage device storing information used by said system for generating animation objects in real time by moφhing a source texture map including plural texels each having plural components, into a target texture map including plural texels each having plural components, said storage device comprising: a first storage portion that stores information controlling said system to calculate incremental moφh parameter values for texels of said first texture map, and to incrementally inteφolate the value of said plural texel components of said first texture map over time by uniform integer amounts based on said calculated incremental moφh parameter values so as to moφh said first texture map through at least one intermediate texture map toward said second texture map; a second storage portion that stores information controlling said system to use said intermediate texture map to texture map an animation object; and a third storage portion that stores information controlling at least one of the displayed orientation and position of said texture-mapped animation object at least in part in response to user manipulation of said control.

Inventors: ABOU-SAMRA SAMIR, CHAMPAGNE ROBERT, COMAIR CLAUDE, FAM SUN TJEN, GHALI PRASANNA, LI XIN, PAN JUN, ABOU-SAMRA, SAMIR, CHAMPAGNE, ROBERT, COMAIR, CLAUDE, FAM, SUN TJEN, GHALI, PRASANNA, LI, XIN, PAN, JUN
Applicants: ABOU SAMRA SAMIR, CHAMPAGNE ROBERT, COMAIR CLAUDE, FAM SUN TJEN, GHALI PRASANNA, LI XIN, NINTENDO CO LTD, PAN JUN, ABOU-SAMRA, SAMIR, CHAMPAGNE, ROBERT, COMAIR, CLAUDE, FAM, SUN TJEN, GHALI, PRASANNA, LI, XIN, NINTENDO CO., LTD., PAN, JUN
Application year: 2000
Main classification: G06T
IPC codes: G06T13, G06T15