Ponotsabban linear texture mapping. A lineáris azt jelenti, hogy egy pixelhez tartozó textúrakoordinátákat (U,V) egyszerű lineáris interpolációval közelítjük, a sarokpontok textúrakoordinátáinak ismeretében. Így a végeredmény természetesen perspektívikusan nem lesz helyes, de azért megjárja. A poligont itt is scanline-okból rakjuk össze. Nézzük egy scanline hogy néz ki a textúrán.

A sarokponontok textúrakoordinátáit (Ua,Va Ub,Vb Uc,Vc Ud, Vd) mi adjuk meg, mikor felépítjük a poligont, a scanline-ok elejét, végét (U0,V0  U1,V1) pedig az Y irányú interpoláció során számoljuk ki. A Scanline-on belül az X irányú interpolációt végezzük. Ugyanaz, mint a Gouraud Shading-nél, csak itt két értéket kell kell végig interpolálni az egész poligonon. Két lépésben, először Y, majd X irányban:

Képletek:
                  Y irányban                                             X irányban
                    U=U0+(y-y0)*(U1-U0)/(y1-y0)                 U=U0+(x-x0)*(U1-U0)/(x1-x0)
                    V=V0+(y-y0)*(V1-V0)/(y1-y0)                 V=V0+(x-x0)*(V1-V0)/(x1-x0)

Ennek megfelelően két egymást követő U és V között mindig ugyanannyi a lépésköz mind X, mind Y irányban.

Lépésközök:

Y irányban:                                        X irányban:
StepU=(U1-U0)/(y1-y0)                         StepU=(U1-U0)/(x1-x0)
StepV=(V1-V0)/(y1-y0)                         StepV=(V1-V0)/(x1-x0)

Ezeket egymás után hozzáadogatva az U-hoz és V-hez, mindig megkapjuk a következő U-t és V-t.A képleteket átgonodolva rájövünk, hogy ha az U1-U0 ,vagy a V1-V0 különbség nagyobb, mint 32767, nem lesz hely az előjelbitre, így nem fog menni a dolog. Ez 256-al felszorzott értékek esetében előfordulhat. Tehát a poligonok megadásakor vigyázni kell, ha az egyik sarok 0,0 akkor a többi max 127,127 lehet. Persze az is megoldás lehet, ha longint-ben (4 byte-on) számolunk.

Az Y irányú interpoláció során egy tömbbe kigyűjtjük minden scanline-ra az elejét, végét, textúrakoordinátát az elejére, végére. Innen kiszedve az értékeket a scanline megrajzolása már egyszerű.

A poligonok felírásánál a körüljárásra is ügyelni kell, mert ez fog segíteni a tömb feltöltésénél,hogy meg tudjuk különböztetni, melyik él a scanline eleje, és melyik a vége. Ha a látható poligonok körüljárása mondjuk óramutató járásával megegyező, akkor a nem látható legyen evvel ellentétes. Így, ha a poligon (feltételezzük, hogy látható) egy élének kezdő Y koordinátája nagyobb, mint a végső, akkor az bal oldalon van, tehát a scanline eleje, ha fordítva, akkor a jobb oldalon. Ha az jön ki, hogy a scanline vége előbb van mint az eleje, akkor a poligon nyílván nem látható.
A számolás során természetesen fixpontosan járunk el. Ha az értékeket 8 bittel léptetjük balra (256-al felszorozva), egy 256X256-os textúra nagyon kényelmesen kezelhető.

Egy Példa az erre a tömbfeltöltögetésre, és Y irányú interpolációra:

Procedure Texline(x1,y1,U1,V1,x2,y2,U2,V2 : integer); var StepX,X : longint;     StepU,U,StepV,V : integer;     dist : word;     y : integer; begin { a koruljarasi iranyunk miatt, a lathato poligonok bal szelen  az  y1<y2 mindig igaz}       {bal oldalt szamoljuk}       if y1<y2 then       begin             dist:=y2-y1+1;             StepX:=(longint(x2-x1) shl 16) div dist; {X 16 bittel
fel} {16.16}
            StepU:=(U2-U1) div dist;         {A 8 bittel fel}  {8.8}             StepV:=(V2-V1) div dist;         {A 8 bittel fel}  {8.8}             X:=longint(x1) shl 16;             {X 16 bittel fel}             U:=U1;                             {A 8 bittel fel}             V:=V1;             for y:=y1 to y2 do             begin                   {bal oldal, scanline eleje-> x0 a0}                   Lines[y].x0:=X shr 16; {16 bittel vissza}                   Lines[y].U0:=U;        {8.8}                   Lines[y].V0:=V;        {8.8}                   X:=X+StepX;                   U:=U+StepU;                   V:=V+StepV;             end;      end; { a koruljarasi iranyunk miatt, a lathato poligonok jobb szelen az y1>y2 mindig igaz}      {jobb oldalt szamoljuk}      if y1>y2 then      begin            if (y1<0) or (y2>199) then exit;            dist:=y1-y2+1;            StepX:=(longint(x1-x2) shl 16) div dist;            StepU:=(U1-U2) div dist;         {A 8 bittel fel}  {8.8}            StepV:=(V1-V2) div dist;         {A 8 bittel fel}  {8.8}            U:=U2;            V:=V2;            X:=longint(x2) shl 16;            for y:=y2 to y1 do            begin                  {jobb oldal, scanline vege ->x1,a1}                  Lines[y].x1:=X shr 16; {16 bittel vissza}                  Lines[y].U1:=U;    {8.8}                  Lines[y].V1:=V;    {8.8}                  X:=X+StepX;                  U:=U+StepU;                  V:=V+StepV;            end;      end; end;

Az első és utolsó scanline eltárolására bevezetünk két változót (MinY,MaxY), enélkül nehéz lenne kitalálni mettől meddig tart a poligon Y irányban.

Az Y irányú interpolációt tehát darabonként, élenként végezzük. Egy négyszögnél négyszer kell meghívni ugyanazt a rutint, csak más paraméterekkel. Először az első él kezdő és végpontja, aztán a másodiké és így tovább.

Az X irányú interpoláció:

procedure TexFill; var StepU,U,StepV,V : integer;     x,x0,x1 : integer;     U0,U1,V0,V1 : integer;     dist : integer;     y : word; begin     for y:=MinY to MaxY do     begin           x0:=Lines[y].x0;           x1:=Lines[y].x1;           U0:=Lines[y].U0;           U1:=Lines[y].U1;           V0:=Lines[y].V0;           V1:=Lines[y].V1;           {scanline hossza}           dist:=x1-x0+1;           if (x1<0) or (x0>319) or (dist<1) then exit;           {lepeskoz}           StepU:=(U1-U0) div dist; {8.8}           StepV:=(V1-V0) div dist; {8.8}           U:=U0;           V:=V0;           {Scanline}           for x:=x0 to x1 do           begin                 screenbuf^[y,x]:=Mem[TexSeg:256*(V shr 8)+(U shr 8)];                 U:=U+StepU;                 V:=V+StepV;           end;     end; end;

Csak a már feltöltött tömbből kiszedet két végpont közöt interpolálunk.

Egy scanline rajzolása pszeudokodban:
 

For x=x0 to x1 { C=texture[U,V] Plot(c) U=U+StepU V=V+StepV }

Egy scanline asm-ben, minden U,V érték 8 bittel balra tolva. (8.8 fixpontos):
Si=V
Dx=U
Bp=StepU
Di=A scanline-on az első pixel képernyőcíme
Es=ScreenBuffer
Fs=textura szegmense
Cx=scanline hossza
 

@@sl: mov bx,si ;bh=V*256 mov bl,dh ;bl=U mov al,fs:[bx] ;al=texture[V*256+U] stosb add si,StepV add dx,bp loop @@sl
(Így sokkal szebb, mint pascal-ban)
Elsőre talán nem egyértelmű, de két mov-ból elértük, hogy:
Bx=256*V+U
Tehát a keresett byte-ra mutat a textúrán, amit rögtön ki is lökünk a képernyőbufferbe.

Van egy elméletibb, lassabb példaprogi kevés assembly-vel pascalban forrkod1.zip
Meg egy gyorsabb gyakorlatiasabb sok assembly-vel Borland C-ben.    forrkod2.zip
(Mondjuk egyik sincs agyonkommentezve)