WO2005124693A2

WO2005124693A2 - Inverse texture mapping 3d graphics system

Info

Publication number: WO2005124693A2
Application number: PCT/IB2005/051897
Authority: WO
Inventors: Kornelis Meinds
Original assignee: Koninklijke Philips Electronics N.V.
Priority date: 2004-06-16
Filing date: 2005-06-09
Publication date: 2005-12-29
Also published as: CN101006471B; JP2008502979A; WO2005124693A3; CN101006471A; EP1766584A2

Abstract

An inverse texture mapping 3D graphics processor maps a 3D model (WO) onto a screen space (SSP). A texture memory (TM) stores texel intensities TI(ug,vg) of texture space grid positions (ug,vg). A plurality of screen space rasterizers (SRASj) determines pixel grid positions (xgi,ygi) within different screen space polygons (SGP) at a plurality of corresponding different display instants (tj) during a same temporal interval (Tf) between sample instants of geometric data of the 3D model (WO). The screen space polygons (SGP) have different positions in the screen space (SSP) dependent on motion information of the 3D model (WO). A plurality of corresponding mappers (MAPj) map the pixel grid positions (xgi,ygi) of the screen space polygons (SGP) at the different display instants (tj) to texture space positions (uj,vj). A texture space resampler (TSR) determines texel intensities (PI(uj,vj)) at the texture space positions (uj,vj) from the texel grid intensities (TI(ug,vg)) of the texture space grid positions (ug,vg) stored in the texture memory (TM). A texture cache (TC) temporarily stores, for every texture space polygon (TGP), the texel intensities TI(ug,vg) required by the texture space resampler (TSR) during the temporal interval (Tf) for all the screen space polygons (SGP) which are associated with a same texture space polygon (TGP). A plurality of corresponding pixel shaders (PSj) determine, at said different display instants (tj), pixel intensities (PSI(xgj,ygj)) from the texel intensities (PI(uj,vj)).

Description

Inverse texture mapping 3D graphics system

Field of the invention The invention relates to an inverse texture mapping 3D graphics processor, a graphics adapter comprising the 3D graphics processor, a computer comprising the 3D graphics processor, a display apparatus comprising the 3D graphics processor, and a method of inverse texture mapping.

Background of the invention The known inverse texture mapping (further referred to as ITM) is elucidated in detail with respect to Figs. 1, 2 and 3. Such an ITM system is able to generate data for display on a display screen at a particular display frame rate depending on the available amount of recourses such as memory bandwidth and computational power and the 3D scene complexity. A higher display frame rate requires a higher amount of these recourses and the complete ITM processing has to be adapted to be able to provide this higher display frame rate.

Summary of the invention It is an object of the invention to provide an ITM system that is able to provide frame rate up-conversion without increasing the data bandwidth to the texture memory. A first aspect of the invention provides an inverse texture mapping 3D graphics processor as claimed in claim 1. A second aspect of the invention provides a graphics adapter comprising the 3D graphics processor, as claimed in claim 10. A third aspect of the invention provides a computer comprising the 3D graphics processor, as claimed in claim 11. A fourth aspect of the invention provides a display apparatus comprising the 3D graphics processor, as claimed in claim 12. A fifth aspect of the invention provides a method of inverse texture mapping as claimed in claim 13. Advantageous embodiments are defined in the dependent claims. The inverse texture mapping 3D graphics processor in accordance with the first aspect maps a 3D model onto screen space. The graphics processor comprises a texture memory for storing texel intensities of texture space grid positions. A plurality of screen space rasterizers determine pixel grid positions within different screen space polygons at a plurality of corresponding different display instants during a same temporal interval between sample instants of geometric data of the 3D model. The pixel grid positions in screen space are considered to be positioned on a grid, the pixel intensities related to these pixel grid positions will be stored in a frame buffer memory and are used to display the image. These different instants are referred to as display instants because the screen space projection of the 3D model is rendered for displaying at these instants. The ratio between the number of display instants and sample instants is the frame rate up-conversion factor. At these different display instants, the screen space polygons associated with the same polygon of the 3D model have different positions in the screen space dependent on motion information of the 3D model with respect to the camera position (also called eye position). A plurality of corresponding mappers maps the pixel grid positions of the screen space polygons at the different instants to texture space positions that usually do not coincide with the texel grid positions on which the texel intensities are stored. A texture space resampler determines texel intensities at the mapped screen space positions from the texel grid intensities of the texture space grid positions stored in the texture memory or in texture cache. A texture cache temporarily stores, for every texture space polygon, the texel grid intensities required by the texture space resampler during the temporal interval for all the screen space polygons being associated with a same texture space polygon. If a texture within a polygon would not fit in the texture cache a strategy of partitioning the polygon in smaller parts (e.g. blocks) could be used. A plurality of corresponding pixel shaders determine, at said different display instants, pixel intensities optionally from the texel intensities received from the texture space resampler and optionally on the basis of a formula such as the well known Gouraud shading. Thus, the same texture samples stored in the texture cache can be used for all the associated screen space polygons during a same temporal interval wherein the plurality of rendering instants occurs. Thus, the texture needs to be fetched once per temporal interval from the texture memory and not for every display instant. Consequently, the data rate between the texture cache and the texture memory does not depend on the frame rate up- conversion factor. This is an important improvement because the data rate to the texture memory is limited by the speed of the texture memory and by the data rate on the bus to the texture memory. This is especially relevant if the texture memory is present on a separate chip. In an embodiment as claimed in claim 2, the motion information comprises motion data that can be used to determine the path of motion of the polygon in the screen space within the temporal interval. The vertices of the polygon(s) and the mapping of pixels to texture space can be determined from this path of motion. It has to be noted that the vertices of a polygon can have different paths of motion. Thus, the path of motion of the polygon is determined by the path of motion of each of the vertices of the polygon. In an embodiment as claimed in claim 3, the motion information is a displacement vector that indicates a displacement of the vertices of the polygon in the screen space between two sample instants. The displacement at a particular one of the rendering instants can be determined by (linearly) interpolating the displacement defined by the displacement vector. In an embodiment as claimed in claim 4, motion data is used in the form of two model/view matrices one for the current sample instant and one for the previous sample instant. With these two matrices, a motion vector in screen space can be determined. Also, the parameters of the mapping functions of the mappers for different rendering instants between two successive sample instants can be determined from this information. This is a robust and efficient method to obtain displacement vectors in the eye or world space. To determine the eye space displacement vectors, the vertices of the previous frame (or more general: the temporal interval) can be subtracted from the vertices of the current frame. Thus, the 3D system calculates the coordinates of the eye space vertices for both the current frame instant (or more general: the current sample instant) and the previous frame instant. The 3D application needs to send, next to the normal model- view matrix an additional model- view matrix for the previous frame instant. The application may buffer the model- view matrices to efficiently resend them. The geometry transformation unit of the 3D system applies both model- view matrices to transform each vertex to a "current" and a "previous" position in eye space. In an embodiment as claimed in claim 5, the motion information is provided by the 3D application. Alternatively, although more complex, the ITM 3D graphics processor may determined the motion information by relating the vertices of the geometry of the current sampling instant with that of the previous sampling instant. In an embodiment as claimed in claim 6, the ITM processor comprises a plurality of frame buffers for storing the intensities that are determined at the screen grid positions. Each frame buffer stores a rendered image for a particular one of the display instants. Thus, by reading out and displaying all the frame buffers sequentially during a single temporal interval, the frame rate up-conversion is obtained. In an embodiment as claimed in claim 7, for a particular one of the 3D models (WO) no texture maps are stored in the texture cache (TC) and the pixel shaders (PSj) are arranged to perform pixel shading on basis of non-texture data. In an embodiment as claimed in claim 8, the ITM processor controls the mappers to perform an identical mapping to the frame buffers for non-moving objects. In fact only one of the mappers needs to perform the mapping and the output obtained this way is copied to all the frame buffers. These and other aspects of the invention are apparent from and will be elucidated with reference to the embodiments described hereinafter.

Brief description of the drawings In the drawings: Fig. 1 shows a display of a 3D object on a display screen, Fig. 2 shows a block diagram of a prior art inverse texture mapping 3D graphics system, Figs. 3 A and 3B illustrate the operation of the inverse texture mapping system, Fig. 4 shows a block diagram of the inverse texture mapping 3D graphics system in accordance with an embodiment of the invention, Figs. 5A and 5B illustrate the operation of the embodiment of the inverse texture mapping system shown in Fig. 4, Fig. 6 shows a computer comprising the inverse texture mapping system, and Fig. 7 shows a display apparatus comprising the inverse texture mapping system.

Detailed description of the preferred embodiment Fig. 1 elucidates the display of a 3D object WO in world space on a display screen DS. Instead of the world space the object may also be available in other 3D spaces such as model or eye space, in the following all these spaces are referred to as world space. An object WO, which may be a three-dimensional object such as the cube shown, is projected on the two-dimensional display screen DS. A surface structure or texture defines the appearance of the three-dimensional object WO. In Fig. 1 the polygon A has a texture TA and the polygon B has a texture TB. The polygons A and B are with a more general term also referred to as graphics primitives. The projection on to the display screen DS of the object WO is obtained by defining an eye or camera position ECP within the world space. Fig. 1 shows how the polygon SGP projected on the screen DS is obtained from the corresponding polygon A. The polygon SGP in the screen space SSP is defined by it's vertex coordinates in the screen space SSP. It is only the projection of the geometry of the polygon A which is used to determine the geometry of the polygon SGP. Usually, it suffices to know the vertices of the polygon A and the projection to determine the vertices of the polygon SGP. The texture TA of the polygon A is not directly projected from the real world onto the screen space SSP. The different textures of the real world object WO are stored in a texture map memory TM (see Fig. 2) or texture space TSP defined by the coordinates u and v. For example, Fig. 1 shows that the polygon A has a texture TA which is available in the texture space TSP in the area indicated by TA, while the polygon B has another texture TB which is available in the texture space TSP in the area indicated by TB. The polygon A is projected on the texture space TA to obtain a polygon TGP such that when the texture present within the polygon TGP is projected on the polygon A the texture of the real world object WO is obtained or at least resembled as much as possible. A perspective transformation PPT between the texture space TSP and the screen space SSP projects the texture of the polygon TGP on the corresponding polygon SGP. This process is also referred to as texture mapping. Usually, the textures are not all present in a global texture space, but every texture defines its own texture space TSP. It has to be noted that the textures in the texture space TSP are stored in a texture memory TM for a discrete number of positions in the texture space TSP. Usually these discrete positions are the grid positions in the texture space TSP determined by integer values of u and v. These discrete grid positions are further referred to as grid texture positions or grid texture coordinates. Positions in the texture space which are not limited to the grid positions are referred to as positions in the texture space TSP or as positions in the u,v space TSP. The positions in the u,v space may be represented by floating point numbers. In a same manner, the image to be displayed is stored in a frame buffer memory. Again, only a discrete number of positions in the x,y space or screen space SSP is available. Usually, these discrete positions are the grid positions in the screen space SSP determined by integer values of x and y. These discrete grid positions are referred to as grid screen positions or grid screen coordinates. Positions in the x,y space which are not limited to the grid positions are referred to as positions in the x,y space or as positions in the screen space SSP. These positions in the x,y space may be represented by floating point numbers. In the now following, the term graphics primitive indicates a polygon (such as polygon A) in the world space, or the polygon SGP in the screen space SSP, or the polygon TGP in the texture space TSP. It is clear from the context which graphics primitive is meant. Fig. 2 shows a block diagram of a prior art inverse texture mapping 3D graphics system. The vertex transformation and lighting unit VER, further also referred to as the vertex T&L unit, transforms the vertex coordinates of the polygon A; B in world space to the screen space SSP to obtain screen space coordinates x_vl,y_vl to x_v3,y_v3 of the vertices of the screen space polygon SGP. The vertex T&L unit further performs light calculations to determine an intensity (also referred to as color) per vertex. If a texture TA, TB is to be applied to a screen space polygon SGP, the vertex T&L unit receives texture space coordinates u_vι,v_vι to u_v3,v_v3 from the application. The vertex T&L unit supplies both the screen space coordinates x_v,y_v ( vijVvi; Xv₂,y_v2; x_v3,y_v3 in Fig. 3A) and the texture space coordinates u_v,v_v (u_vι,v_vι; u_v2,v_v2; u_v3,v_v3 in Fig. 3B) of the vertices of the screen space polygons SGP and the texture space polygons TGP, respectively, such that the position thereof in the screen space SSP and the texture space TSP, respectively, is known. Usually, the positions of the vertices will not coincident with the screen space grid positions or texture space grid positions, respectively. The screen space rasterizer SRAS determines the grid positions x_g,y_g of the pixels which are positioned within the screen space polygon SGP which is determined by the screen space coordinates x_v,y of its vertices. In the example shown in Fig. 3 A, these screen space grid positions x_g,y_g within the screen space polygon SGP are indicated by crosses. The rasterizer SRAS may include a so called rasterizer setup which initializes temporal variables required by the rasterizer SRAS for efficient processing based on interpolation of the vertex attributes. The mapper MAP maps the screen space grid positions x_g,y_g to corresponding texture space positions u,v in the texture space TSP, see Figs. 3. Generally, these texel positions u,v will not coincident with texture space grid positions u_g,v_g. The pixel shader PS determines the intensity PSI(x_g,y_g) (also referred to as color) of a pixel with the screen space coordinates x_g,y_gand thus the texture space coordinates u,v. The pixel shader PS receives a set of attributes ATR per pixel, the grid screen coordinates x_g,y_g of the pixel and the corresponding texture coordinates u,v. The texture coordinates u,v are used to address texture data TI(u_g,v_g) on grid texture positions U_g,v_g stored in the texture memory TM via the texture space resampler TSR. The pixel shader PS may modify the texture coordinate data u,v and may apply and combine several texture maps on the same pixel. It also may perform shading without the use of texture data but on basis of a formula such as the well known Gouraud and Phong shading techniques. The texture space resampler TSR determines the intensity PI(u,v) associated with the intensity PSI(x_g,y_g) of the pixel at the screen space grid position (x_g,y_g) mapped to the texture space coordinate (u,v) in-between texel grid positions (u_g,v_g). The texture data TI(u_g,V_g) corresponding to the texture space grid position u_g,v_g is indicated by TI(u_g,v_g). The texel intensities TI(u_g,v_g) for texture space grid positions u_g,v_g are stored in the texture memory TM. The texture space resampler TSR determines the intensity PI(u,v) by filtering and accumulating the texel intensities TI(u_g,u_v) of texels with texture space grid coordinates Ug,v_g and which have to contribute to the intensity PI(u,v). Thus, the texture space resampler TSR determines the intensity PI(u,v) at the texture space position u,v by filtering the texel intensities on texture space grid positions u_g,v_g surrounding the texture space position u,v. For example, a bilinear interpolation using the four texture space grid positions u_g,v_g (indicated in Fig. 3B with 1 to 4) surrounding the texture space position u,v may be used. The resulting intensity PI(u,v) at the position u,v is used by the pixel shader PS to determine the pixel intensity PSI(x_g,y_g) on the pixel grid position x_g,y_g. The hidden surface removal unit HSR, usually includes a Z-buffer which enables determination of the visible colors on a per pixel basis. The depth value z of a produced pixel value PSI(x_g,y_g) is tested against the depth value of the one stored in the Z- buffer at the same pixel screen coordinate x_g,y_g (thus on the screen grid). Depending on the outcome of the test, the pixel intensity or color PIP(x_g,y_g) is written into the frame buffer FB and the Z-buffer is updated. The image to be displayed IM is read from the frame buffer FB. It has to be noted that usually a texture cache is present between the texture space resampler TSR and the texture memory TM. Usually, the application provides the polygons in groups to minimize texture state switches. Each one of the groups of polygons is related to a same one of the textures. The texture used for a particular group of polygons is stored whole or partially in the texture cache and the texture data can be fetched from texture cache by subsequent polygons from the same group. With the start of a next group of polygons another texture whole or partially is loaded into the texture cache. During the processing of the polygons of a group, the texture memory TM fetches are minimized because all or almost all texture information is present in the texture cache. Figs. 3 A and 3B illustrate the operation of the inverse texture mapping system. Fig. 3A shows the screen space polygon SGP in the screen space SSP. The vertices of the polygon SGP are indicated by the screen space positions x_vι,y_vι; v2,y_v2; v₃,y_V3 which usually do not coincide with the screen space grid positions x_g,y_g- The screen space grid positions x_g,y_g are the positions which have integer values for x and y. The image to be displayed is determined by the intensities (color and brightness) PIP(x_g,y_g) of the pixels which are positioned on the screen space grid positions x_g,y_g. The rasterizer SRAS determines the screen space grid positions x_g,y_g within the polygon SGP. These screen space grid positions x_g,y_g are indicated with a cross and are also referred to as the pixel positions. Fig. 3B shows the texture space polygon TGP in the texture space TSP. The vertices of the texture space polygon TGP are indicated by the texture space positions u_vι,v_vι; u_v2,v_v2; u_v3,v_v3 which usually do not coincide with the texture space grid positions u_g,v_g. The texture space grid positions u_g,v_g are the positions which have integer values for u and v. The intensities of the texels TI(u_g,v_g) are stored in the texture memory TM for these texture space grid positions u_g,v_g. There may be stored several texture maps in different resolutions of the same texture. A known technique which uses these different resolution textures is called MlP-mapping. The texture space grid positions u_g,v_g within the polygon TGP are indicated by dots in Fig. 4B. The mapper MAP maps the screen space grid coordinates x_g,y_g to corresponding texture space positions u,v in the texture space. The intensity at a texture space position u,v is determined by filtering. For example, the intensity at the texture space position u,v which is, or contributes to, the intensity of the pixel at the screen space grid position x_g,y_g, is determined as a weighted sum of intensities at surrounding texture space grid positions u_g,v_g. For example, a weighted sum of the texel intensities TI(u_g,v_g) at the texture space grid positions u_g,v_g indicated by 1, 2, 3 and 4 is determined. Fig. 4 shows a block diagram of the inverse texture mapping 3D graphics system in accordance with an embodiment of the invention. The basic structure of the ITM shown in Fig. 4 is identical to the known ITM shown in Fig. 2. The difference is that a plurality of pipelines formed by the transform and lighting module VERj, the rasterizer

SRASj, the mapper MAPj, the pixel shader PSj, the hidden surface removal unit HSRj, and the frame buffer FBj is present instead of the single pipeline of Fig. 2. The index j indicates that the item known from Fig. 2 is the j^th item with 1< j < n. Thus if n = 4, all the items with the index j are present four times and each one is indicated by one of the indices j running from 1 to 4. All the items of Fig. 4 operate in the same manner as the corresponding items of Fig. 2. In a practical embodiment, the items may be hardware which is present multiple times, or the same hardware may be used in a time multiplexing mode, or a combination of these two possibilities may be implemented. What counts is that now the processes in Fig. 2 occur j times at j different rendering instants tj. Thus, in accordance with the invention, the same texture space polygon TSP with the same texture is used at different display instants. Thus, if this texture is stored in the texture cache TC, the texture has to be retrieved from the texture memory TM only once for all the different display instants. It has to be noted that the use of parallel pipelines as such is known. However, these know parallel pipelines are used to obtain a higher performance

(more polygons and pixels per second are processed). These known systems do not store the same texture space polygon TSP with the same texture in the texture cache TC for use at different display instants to reduce the data traffic of the texture memory TM. The texture cache TC in accordance with the prior art ITM system as discussed with respect to Fig. 2 does also store a particular texture but this texture is used for the different polygons of the groups of polygons which require the same texture and not for the same polygon at different display instants. Also, the signals (data) shown in Fig. 4 are the same as in Fig. 2, the only difference is that the index j is added to indicate that the signals depend on the rendering instant tj. The operation of the ITM system shown in Fig. 4 will be elucidated with respect to Figs. 5. Figs. 5 A and 5B illustrate the operation of the embodiment of the inverse texture mapping system shown in Fig. 4. Fig. 5 A shows the screen space polygon SGP1 at the render instant tl, and the screen space polygon TGPn at the render instant tn. For the sake of clarity other polygons at other render instants tj, if present (if n >2, 1 < j < n), are not shown. Fig. 5B is identical to Fig. 3B. Fig. 5 A shows the screen space polygon SGP1 and SGPn, both are mapped from the same source polygon from the world space WO, only a different mapping has been used according to the associated render instant tl, tn along the motion path. The display instants tl to tn are collectively also referred to as tj, the screen space polygons SGP1 to SGPn are also collectively referred to as screen space polygons SGPj. The position of the screen space polygons SGPj depends either on the motion data provided by the application or on motion data determined from the positions of the screen space polygons SGPj at two successive sample instants ts of the geometric data. The 3D application may be a 3D game, a VRML browser, a 3D user interface, a MPEG 4 visual renderer, visiophony or any other 3D application. Although in Fig. 5 the screen space polygon SGPn is a translated version of the screen space polygon SGP1, other movements than across a straight line are as well possible. The vertices of the screen space polygon SGP1 are indicated by the screen space positions x_vl 1 ,y_vl 1 ; x_v12,y_v12; x_v13,y_v13 which usually do not coincide with the screen space grid positions x_g,y_g. The vertices of the screen space polygon SGPn are indicated by the screen space positions x_vnl,y_vnl; x_vn2,y_vn2; x_vn3,y_vn3. The vertices u_vl,v_vl to u_v3,v_v3 of the texture space polygon TGP are provided by the 3D application and stay the same in time (or at least during a certain period in time). It is the same texture which has to be applied to the moving projection (defined by the different screen space polygons SGPj) in the screen space SSP. The moving 3D model together with the perspective mapping to the screen space SSP determines the vertices of the screen space polygons SGPj. It has to be noted that the index j is used to refer to the items related to the plurality of the n screen space polygons SGP1 to SGPn. The image IM to be displayed is determined by the intensities PIP(x_gj,y_gj) of the pixels which are positioned on the screen space grid positions

For example, if n = 4, the display rate (also called frame rate) of the image IM is four times higher than the sample rate of the input data supplied by the 3D application. Or said differently, in one temporal interval Tf four display instants tj (tl to t4) occur to which four positions of the screen space polygon SGPj in the screen space SSP are associated. The temporal interval Tf is the period of time between two successive sample instants of the geometric data supplied by the 3D application. In prior art systems often the temporal interval between two displayed rendered images (frames) is referred to as the frame period and is equal to the sampling period of the input signal (sampling of the geometry delivered by the 3D application). However, in the system in accordance with the invention the frame period of the output signal is determined by the number of display instants tj occurring within the temporal interval Tf or the sample period of the input signal. The geometric data comprises the vertices of the texture space polygon TGP, data defining the perspective mapping from the 3D space to the screen space SSP, and the motion data. Preferably, the motion data is provided which indicates the motion path of the vertices of the screen space polygons SGPj within the temporal interval Tf. The motion data can be used to obtain the motion path which may be described with a displacement vector which indicates the displacement of vertices of the polygon from the previous sampling instant to the current sampling instant. The displacement vectors of the vertices of a polygon may differ in direction and size. For example a triangle polygon may rotate around one of it's vertices (so displacement size of that vertex is zero) and then the displacement vectors of the two other vertices (if they are not co-inside) differ in direction (and size if the distance of both vertices to the first differs). However, instead of displacement vectors the motion data may be a more advanced description of the motion path, such as, for example, curves described with conies, composite curves, Bezier curves, B- spline curves, or rational polynomials. In the case of curved motion paths, motion data determined from the positions of the screen space polygons SGPj at more than two successive sample instants ts of the geometric data may be used. Preferably, the application should supply the motion data together with the geometry data. However, in special cases, it is also possible to detect the motion data from the geometry data at different sampling instants. The vertex transformation and lighting unit VER is splitted into a plural of units indicated by VERj. Each unit VERj transforms the world space vertex coordinates to screen space coordinates of the vertices of the polygons SGPj and calculates a vertex color depending on lighting state and the vertex position at display instant tj. At each one of the rendering instants tj, the rasterizer SRASj determines the screen space grid positions Xgj,ygj within the polygon SGPj. Thus, at the rendering instant tl, the rasterizer SRAS1 determines the screen space grid positions x_gl,y_gl within the polygon SGP1. These screen space grid positions Xgj,ygj inside the screen space polygons SGPj are indicated with a cross and are also referred to as the pixel positions. The mappers MAPj map the screen space grid positions X_gj,ygj within the screen space polygons SGPj to the texture space coordinates uj,vj which generally do not coincident with the texture space grid coordinates u_g,v_g for which the intensities TI(u_g,v_g) are stored in the texture memory TM. The texture space grid positions u_g,v_g are the positions which have integer values for u and v. Because of the fact that the same texture space polygon TGP is required to provide the texture to the different screen space polygons SGPj, the mappers MAPj always map the screen space grid positions Xgj,ygj inside the different screen space polygons SGPj to texture space coordinates uj,vj inside the same texture space polygon TGP. The pixel shaders PSj each receive a set of attributes ATR per pixel, the grid screen coordinates X jjVgj of the pixel and the corresponding texture coordinates uj,yj. The texture coordinates uj,vj are used to address texture data TI(u_g,v_g) on grid texture positions u_g,Vg stored in the texture memory TM via the texture space resampler TSR and the texture cache TC. The pixel shaders PSj may modify the texture coordinate data uj,vj and may apply and combine several texture maps on the same pixel. They also may perform shading without the use of texture data but on basis of a formula such as the well known Gouraud and Phong shading techniques. The texture space resampler TSR determines the intensity PI(uj,vj) associated with the intensity PSI(Xgj,y_gj) of the pixel at the screen space grid position (x^y^^') mapped to the texture space coordinate (uj,vj) in-between texel grid positions (u_g,v_g). The texel intensities TI(u_g,v_g) for the texture space grid positions u_g,v_g are stored in the texture memory TM. The texture space resampler TSR determines each one of the intensities PI(uj,vj) by filtering and accumulating the texel intensities TI(u_g,u_v) of texels which have texture space grid coordinates u_g,v_g and which have to contribute to the intensity PI(uj,vj). Thus, the texture space resampler TSR determines the intensity PI(uj,vj) at the texture space position uj,vj by filtering the texel intensities on texture space grid positions u_g,v_g surrounding the texture space position uj,vj. For example, a bilinear interpolation using the four texture space grid positions u_g,v_g (indicated in Fig. 5B with 1 to 4) surrounding the texture space position uj,vj may be used. The resulting intensity PI(uj,vj) at the position uj,vj is used by the pixel shader PS to determine the pixel intensity PSI(Xgj,ygj) on the pixel grid position ^y^. The texture cache TC temporarily stores the texel intensities TI(u_g,v_g) required for the determination of all the intensities PI(uj,vj) of the texture space coordinate (uj,vj) mapped by the mappers MAPj. The pixel shaders PSj determine the contributions of the intensities PI(uj,vj) to the pixel intensities PSI(Xgj,ygj). Thus, if all these contributions to the pixel intensities PSI(X_gj,ygj) are determined for the same texture space polygon TGP at all the display instants tj, successively for each screen space polygon SGP, the data traffic between the texture cache TC and the texture memory TM is not increased compared to rendering of only a single screen space polygon SGP, if all the texel intensities TI(u_g,v_g) of the current polygon fit in the texture cache TC. If all the texels applied on the screen space polygon SGP do not fit within the texture cache TC the polygon SGP can be subdivided into smaller parts (e.g. in blocks or other polygons) such that the texels of such a part do fully fit into the texture cache TC. Still, in every temporal interval Tf for every texture space polygon TGP only one fetch of the relevant data from the texture memory TM is required, independent on the number of rendering instants tj. The data bandwidth between the texture cache TC and the texture space resampler TSR increases with a factor equal to the number of rendering instants tj and thus with the frame rate up-conversion factor. Consequently, if the external texture memory TM is connected to the rest of the ITM system via a bus, the data rate on this bus does not depend on the frame rate up-conversion factor. This in contrast to the prior art ITM system which does not have the texture cache TC and which does not process the texture space polygons TGP one by one, each one for all rendering instants tj. The hidden surface removal units HSRj, usually include a Z-buffer which enables determination of the visible colors on a per pixel basis. Usually, the Z-buffer has the size of a frame or a tile. In case of tile-based rendering, the tile size is relatively small and can even be made smaller for optimal use of the cache in the present frame rate up- conversion technique. The depth value z of a produced pixel value PSI(Xgj,ygj) is tested against the depth value of the one stored in the Z-buffer belonging to the frame buffer FBj at the same pixel screen coordinate X_gj,y_gj (thus on the screen grid). Depending on the outcome of the test, the pixel intensity or color PIP(xgj,ygj) is written into the frame buffer FBj and the Z-buffer belonging to FBj is updated. The image to be displayed LM is read from the frame buffer FBj. The intensities of the texels TI(u_g,v_g) are stored in the texture memory TM for the texture space grid positions u_g,v_g. There may be stored several texture maps in different resolutions" of the same texture. A known technique that uses these different resolution textures is called MlP-mapping. The texture space grid positions u_g,v_g within the texture space polygon TGP are indicated by dots in Fig. 5B. The mappers MAPj map the screen space grid coordinates Xgj,ygj to corresponding texture space positions uj,vj in the texture space TSP. The intensity PI(uj,vj) at a texture space position uj,vj is determined by filtering. For example, the intensity PI(uj,vj) at the texture space position uj,vj which is, or contributes to, the intensity PSI(Xgj,ygj) of the pixel at the screen space grid position Xgj,ygj, is determined as a weighted sum of intensities at surrounding texture space grid positions u_g,v_g. For example, a weighted sum of the texel intensities TI(u_g,v_g) at the texture space grid positions Ug,v_g indicated by 1, 2, 3 and 4 is determined. Fig. 6 shows a computer comprising the inverse texture mapping system. The computer PC comprises a processor 3, a graphics adapter 2 and a memory 4. The processor 3 is suitably programmed to supply input data II to the graphics adapter 2. The processor 3 communicates with the memory 4 via the bus Dl. The graphics adapter 2 comprises the ITM system 1. Usually, the graphics adapter 2 is a module which is plugged into a suitable slot (for example an AGP slot). Usually, the graphics adapter comprises its own memory (for example the texture memory TM and the frame buffer FB). However the graphics adapter may use part of the memory 4 of the computer PC, now the graphics adapter need to communicate with the memory 4 via the bus D2 or via the processor 3 and the bus Dl . The graphics adapter 2 supplies the output image OI via a standard interface to the display apparatus DA. The display apparatus may be any suitable display, such as, for example, a cathode ray tube, a liquid crystal display, or any other matrix display. The computer PC and the display DA need not be separate units which communicate via a standard interface but may be combined in a single apparatus, such as, for example, a personal digital assistant (PDA or pocket PC) or any other mobile device with a display for displaying images. Fig. 7 shows a display apparatus comprising the inverse texture mapping system. The display apparatus DA comprises the ITM pipeline 1 which receives the input data II (geometry and related data) and supplies the output image OI to a signal processing circuit 11. The signal processing circuit 11 processes the output image OI to obtain a drive signal DS for the display 12. To conclude, in a preferred embodiment, the inverse texture mapping 3D graphics processor maps a 3D model WO onto a screen space SSP. A texture memory TM stores texel intensities TI(u_g,v_g) of texture space grid positions u_g,v_g. A plurality of screen space rasterizers SRASj determines pixel grid positions

within different screen space polygons SGPj at a plurality of corresponding different display instants tj during a same temporal interval Tf between sample instants ts of geometric data of the 3D model WO. The screen space polygons SGPj have different positions in the screen space SSP dependent on motion information of the 3D model WO with respect to the camera. A plurality of corresponding mappers MAPj map the pixel grid positions

of the screen space polygons SGP at the different display instants tj to texture space positions uj,vj. A texture space resampler TSR determines texel intensities PI(uj,vj) at the texture space positions uj,vj from the texel grid intensities TI(u_g,v_g) of the texture space grid positions u_g,v_g stored in the texture memory TM. A texture cache TC temporarily stores, for a texture space polygon TGP, the texel intensities TI(u_g,v_g) required by the texture space resampler TSR during the temporal interval Tf for all the screen space polygons SGP which are associated with a same texture space polygon TGP. A plurality of corresponding pixel shaders PSj determine, at said different display instants tj, pixel intensities PSI(xgj,ygj) from the texel intensities PI(uj,vj). It should be noted that the above-mentioned embodiments illustrate rather than limit the invention, and that those skilled in the art will be able to design many alternative embodiments without departing from the scope of the appended claims. In the claims, any reference signs placed between parentheses shall not be construed as limiting the claim. Use of the verb "comprise" and its conjugations does not exclude the presence of elements or steps other than those stated in a claim. The article "a" or "an" preceding an element does not exclude the presence of a plurality of such elements. The invention may be implemented by means of hardware comprising several distinct elements, and by means of a suitably programmed computer. In the device claim enumerating several means, several of these means may be embodied by one and the same item of hardware. The mere fact that certain measures are recited in mutually different dependent claims does not indicate that a combination of these measures cannot be used to advantage.

Claims

CLAIMS:

1. An inverse texture mapping 3D graphics processor for mapping a 3D model

(WO) onto a screen space (SSP), said graphics processor comprising: a texture memory (TM) for storing texel intensities TI(u_g,v_g) of texture space grid positions (u_g,v_g), a plurality of screen space rasterizers (SRASj) for determining pixel grid positions (x_g,y_g) within different screen space polygons (SGP) at a plurality of corresponding different display instants (tj) during a same temporal interval (Tf) between sample instants of geometric data of the 3D model (WO), wherein the screen space polygons (SGP) have different positions in the screen space (SSP) dependent on motion information of the 3D model (WO), a plurality of corresponding mappers (MAPj) for mapping the pixel grid positions (x_g,y_g) of the screen space polygons (SGP) at the different display instants (tj) to texture space positions (uj,vj), a texture space resampler (TSR) for determining texel intensities (PI(uj,vj)) at the texture space positions (uj,vj) from the texel grid intensities (TI(u_g,v_g)) of the texture . space grid positions (u_g,v_g) stored in the texture memory (TM), a texture cache (TC) for temporarily storing, for every texture space polygon (TGP), the texel intensities TI(u_g,v_g) required by the texture space resampler (TSR) during the temporal interval (Tf) for all the screen space polygons (SGP) being associated with a same texture space polygon (TGP), and a plurality of corresponding pixel shaders (PSj) for determining, at said different display instants (tj), pixel intensities

from the texel intensities (PI(uj,yj)).

2. An inverse texture mapping 3D graphics processor as claimed in claim 1, wherein the motion information comprises motion data determining a path of motion within the temporal interval (Tf).

3. An inverse texture mapping 3D graphics processor as claimed in claim 1, wherein the motion information comprises a displacement vector indicating a displacement of vertices (x_vl l,y_vll;X_vl2,y_v12;Xvl3,y_v13) of the screen space polygon (SGP) at a previous sample instant and vertices (x_vnl,yvnl;Xvn2,y_vι 2;x_vn3,y_vn3) of the screen space polygon (SGP) at a current sample instant.

4. An inverse texture mapping 3D graphics processor as claimed in claim 1, wherein the motion data comprises two model/view matrices, one for a current sample instant and one for a previous sample instant.

5. An inverse texture mapping 3D graphics processor as claimed in claim 1, wherein the motion information is received from a 3D application.

6. An inverse texture mapping 3D graphics processor as claimed in claim 1, further comprising a plurality of frame buffers (FBj) for storing intensities (PIP(x_gj,y_gj)) being determined at the screen grid positions (Xgj,ygj).

7. An inverse texture mapping 3D graphics processor as claimed in claim 1, wherein for a particular one of the 3D models (WO) no texture maps are stored in the texture cache (TC) and wherein the pixel shaders (PSj) are arranged for performing pixel shading on basis of non-texture data.

8. An inverse texture mapping 3D graphics processor as claimed in claim 6, wherein the mappers (MAPj) are arranged for performing an identical mapping to the frame buffers (FBj) for non-moving objects.

9. An inverse texture mapping 3D graphics processor as claimed in claim 1, further comprising means for subdividing the screen space polygon (SGP) into smaller parts if all the texels applied on the screen space polygon (SGP) do not fit within the texture cache (TC) such that the texels of each one of the smaller parts do fully fit into the texture cache (TC).

10. A graphics adapter comprising the inverse texture mapping 3D graphics processor of claim 1.

11. A computer comprising the inverse texture mapping 3D graphics processor of claim 1.

12. A display apparatus comprising the inverse texture mapping 3D graphics processor of claim 1.

13. A method of inverse texture mapping for mapping a 3D model (WO) onto a screen space (SSP), said method comprising: storing (TM) texel intensities TI(u_g,v_g) of texture space grid positions (u_g,v_g), determining (SRASj) pixel grid positions (x_gi,y_gi) within different screen space polygons (SGP) at a plurality of corresponding different display instants (tj) during a same temporal interval (Tf) between sample instants of geometric data of the 3D model (WO), wherein the screen space polygons (SGP) have different positions in the screen space (SSR) dependent on motion information of the 3D model (WO), mapping (MAPj) the pixel grid positions (x_gi,y_gi) of the screen space polygons (SGP) at the different display instants (tj) to texture space positions (uj,vj), determining (TSR) texel intensities (PI(uj,vj)) at the texture space positions (uj,vj) from the texel grid intensities (TI(u_g,v_g)) of the texture space grid positions (u_g,v_g) stored in the texture memory (TM), temporarily storing (TC), for every texture space polygon (TGP), the texel intensities TI(u_g,v_g) required by the texture space resampler (TSR) during the temporal interval (Tf) for all the screen space polygons (SGP) being associated with a same texture space polygon (TGP), and determining (PSj), at said different display instants (tj), pixel intensities

(PSI(Xgj,ygj)) from the texel intensities (PI(uj,vj)).