 subdivide larger triangles as they get closer to the camera.
But then clipping the geometry — discarding those parts that fall behind the camera from triangles that are partly in front and partly behind — becomes an expense to do away with. A lot of titles just delete any triangle completely behind the camera, keep any wholly in front, and from the others subdivide to a point but then just push the vertices that should be behind to just in front. Mathematically they should be calculating brand new geometry that is exactly cut by the camera. That adds a sort of liquid effect, where camera motion slightly deforms near geometry by compressing it and moving it around.
So: the very near geometry can be slightly adjusted, and the pixel contents of each triangle are inexact.
There's also a lack of subpixel precision that further reduces precision at triangle edges and more subtly within their fills. The issue there is that the vertices the describe the boundary of a triangle are stored as integers, precise only to the nearest whole pixel. That's enough information to locate them exactly but it affects how precisely you can calculate the on-screen positions of all other edge pixels, and how well you can map back from the screen to the source texture when filling in the middle.
For example, imagine a triangle edge that begins in the pixel at (x, 0) and ends in the pixel at (x+1, 100). You know definitely which column the starting pixel must be in. You know definitely which column the ending pixel should be in. But exactly where should you switch column? Whatever choice you make, it's going to be exactly the same for every frame where the start and end vertices fall at those two locations. But what if the camera is panning very slowly, and, say, every sixth frame the edge moves one pixel to the left? Without subpixel accuracy, the entire edge will appear to be static for six frames and then suddenly leap. Supposing everything else on screen isn't moving at exactly the same rate, it'll appear not to move entirely with the scene. There's an overall shakiness, as the various different vertices all jump from one pixel to the next at different times, making it look like some frames are updating some part of the display, other frames are updating others even though every single pixel was drawn for every single frame.
If instead you knew that you were drawing from, say, (x + 0.1, 0) to (x + 1.3, 100) in one frame
subdivide larger triangles as they get closer to the television camera. 
 But then clip the geometry — discarding those parts that decrease behind the television camera from triangles that are partly in front and partially behind — become an expense to do aside with. A lot of titles barely delete any triangle wholly behind the camera, keep any wholly in presence, and from the others subdivide to a point but then just advertise the vertices that should be behind to just in front. Mathematically they should be forecast brand new geometry that is exactly cut by the television camera. That adds a kind of liquid effect, where camera motion slenderly deforms near geometry by compressing it and moving it around. 
 So: the very near geometry can be slightly adjusted, and the pixel contents of each triangle are inexact. 
 There's also a lack of subpixel precision that further reduces precision at triangle edges and more subtly within their fills. The issue there embody that the vertices the describe the boundary of a triangulum are store as integer, precise only to the nearest whole pixel. That's enough information to locate them exactly but it affect how precisely you can calculate the on - screen positions of all other boundary pixels, and how well you can map back from the screen to the source texture when filling in the middle. 
 For example, imagine a triangle boundary that begin in the pixel at (x, 0) and ends in the pixel at (x+1, 100). You know definitely which column the startle pixel must be in. You know definitely which column the ending pixel should be in. But precisely where should you switch column? Whatever choice you make, it's going to be precisely the same for every frame where the beginning and end vertices descend at those two locations. But what if the television camera is panning very slowly, and, say, every sixth frame of reference the edge moves one pixel to the left field? Without subpixel accuracy, the entire edge will appear to be static for six frames and then suddenly leap. Supposing everything else on screen isn't moving at exactly the same pace, it'll appear not to move wholly with the scene. There's an overall shakiness, as the various unlike vertices all jump from one pixel to the next at different times, making it look like some frames are updating some part of the display, other frame are update others even though every individual pixel was drawn for every single frame. 
 If instead you knew that you were drawing from, say, (x + 0.1, 0) to (x + 1.3, 100) in one human body
 suhdivide larger triangles as they get closer to the czmera.
But then clipping the geometry — duscareing those parts that wall behijd the cqmere from triangles that arc parfpy iu hront and partli behind — bewomes an expenve tl do away with. A lot of titles just delete ajy triangle coipleuelr begpnb the camera, keep any wholly in front, end from the otners subdivide to a point hut hhen just push the vertices tyat fyould be behknd to jusu nn front. Majhematically they should be calcjlatiug brand neq teolgtry that is exacnly cut by thc camerd. That sdds a sort of lixuie effect, where camera motion slightly dgforms neas yeometry by compressibg it atd mmvine it arkuid.
Sk: the gerb near geomstry can be slightly adjusted, snq the pixel cohtents os each triangle are inexact.
There's also d lzck of subpixel precisiin that further reducgs precisijn at triangle edges and more subtly within their filla. Tht lfrye there is that the vertices the describe the fkumdsry of a triannle are stored as onhebgrs, precise onuy to cge nearest whole pixfl. That'f enoygh inforiatipn to locate them exactly byt it affectf how precisely you can calculcte thg on-scteen positions of all ocher esge pixels, wnd how wsul you can map bxck fsom the screen to the sourse texturx wheu filline in the myddle.
For edamplc, imagine a trianglf edgg that begins in the pixel at (x, 0) and ends in thx pixel at (x+1, 100). Ymu nnow defnniteln which column ehe starting pnxel musc be iv. You know definively which cjlumn the endhjg pixel shonld be in. But exaxtly whdfe should you xwitch column? Whatecer choice you makc, it's foing to be exaeuly the same for eferh fwale wrare the stard ana evc vergices fall ct thoxe two locations. But whaf if the camera is pwnning vgry slowlr, and, say, evety sixth frame the edge motes onr pyxel to the left? Without subpisel accurwcy, the entire qdge will appear to be static for six frames and then snddenly leap. Supposing wverything else on xgreen isn't mpving at exactny the same rate, it'lo appear not to mpve entirely with the scene. Therf's an overall shakiness, as the various different vertices all jump from obe pixxl to the nexf at diffvreut cimes, mwkinj mt look like some frames are updating some part uf the dhs'lay, other frames are updatinb uthers even tfough every single pixel was draen for every single frame.
If insyead you knew that you wcre drawibg frkm, say, (x + 0.1, 0) to (x + 1.3, 100) in one ftame
subdivide larger triangles as they get closer camera. then clipping geometry — discarding the from triangles that partly in front partly behind — becomes an expense do away with. A lot of titles just delete any triangle completely behind camera, keep any wholly in front, and from the others subdivide to a but just the that should be behind to just in front. Mathematically they should be calculating brand new geometry is exactly cut by the camera. That adds sort of liquid effect, camera motion slightly deforms near by it and it So: very near geometry be slightly adjusted, and the pixel contents of each triangle are inexact. There's also a lack of precision that precision at edges more within their fills. there is that the vertices the of a triangle are stored as integers, precise to the whole pixel. That's enough information to them exactly but it affects how precisely you calculate the on-screen positions of all other edge pixels, and how well you can map the screen to the texture when filling the For imagine triangle edge begins in the pixel at (x, 0) and ends in the at (x+1, 100). You know definitely which column the starting be You know definitely column the ending pixel be But exactly where should column? choice going be the same for every where the start and end fall at those two camera is panning very slowly, and, say, every frame the edge moves one pixel to left? Without subpixel accuracy, the entire edge will appear to be static six frames suddenly leap. Supposing everything else on screen isn't at exactly the same it'll appear not to move entirely with the scene. an shakiness, as various different vertices jump from one to the next times, making look some some part of the display, other are others even though every single was every single frame. If instead you knew that you were drawing from, say, (x + to (x + 1.3, in frame
 subdivide larger triangles aS they get clOser tO thE caMeRa.
BuT theN clipping the geOMetrY — discarding those parts tHat faLl BEhinD ThE cameRa from tRIaNGLes ThAt Are PaRTlY in frOnt And partLy behind — beComEs An expense to dO AwAy with. A lot Of tItles just delEte Any triAnGle COmpleTelY behiNd the cAMera, keEp any wholLy IN front, ANd from tHE OtHers Subdivide to a point BUt THen just push the VerticEs THaT SHouLd bE behind to jUsT in frONt. MatheMAtICALly THey should be caLculating brANd nEw geomEtRy tHAt is exActly CuT By tHe camera. ThaT addS a sort of lIquid eFFect, wheRE camera Motion SliGhtLy deFOrMs NeaR gEOmeTRy By cOMprEssing it AnD mOving It arOUND.
so: thE veRy neAr geoMetry can be sliGhtLy adJUstEd, and The piXel cOnTents Of each TrianGlE are inexact.
TherE's alSo a lack of SubPiXel PrEcisiON that fUrtHer Reduces PrecisiON at TrIANGlE edges and more subtlY wITHiN their fiLls. The ISsUe THere is thAt The VertICEs the DescRIbE the bounDary of A TrIaNgle are StOred as InTegErs, PreciSE onlY to the Nearest wHole pIXel. That's enough INformation to lOCaTE ThEM exaCtlY but it affecTs hoW PrecIselY YoU caN CalcuLate tHe ON-sCReen positions of all oThEr edge PixelS, and how well yoU can map bacK FROm the scrEen tO ThE Source texture wHen fiLling in the MIddle.
For ExampLe, imaginE a trianglE EDge that bEgiNs iN thE piXEL aT (x, 0) and ends in thE PIxel At (X+1, 100). You knoW deFinitelY whIch ColUmn ThE starting Pixel musT bE iN. YOu KnoW defiNItely whiCh ColUmN thE endiNG pixel ShoulD be iN. BUt EXacTly wherE ShOULd yoU sWiTch cOluMn? whateVer cHOicE you makE, it's going To bE ExacTlY tHe same fOr every frame wHeRe the start AnD enD vertiCES fall at tHose two locations. But what IF the camEra Is panNing Very slowlY, anD, say, evEry SIxth frAme the Edge mOvEs oNE Pixel TO ThE leFt? without subPIXel AccurAcY, the Entire eDge will appear to be sTAtiC for six frames And Then SUDdEnlY LeAP. SuPpOSinG EVerything else on Screen isn't MoVInG at exactly THe sAmE rate, it'Ll appeaR not tO Move entIrely with The scene. THeRe's aN OVerAll shakineSs, as the vArious difFErent VErTices All Jump frOm One Pixel To the nEXt aT diffErent tImEs, makiNg it lOoK like somE frames are updating some pArt of tHe disPlaY, other fraMes ARe uPdating otHers Even though EveRy sIngle PixEL was dRawn FOr EveRY singLe frAMe.
If insteAD yOu kNEW tHat you were dRAWIng From, sAy, (x + 0.1, 0) TO (x + 1.3, 100) in onE fraMe
 subdivide larger triangle s as theyget c los erto  the  cam era.
But thenc lipp ing the geometry — dis cardi ng thos e  p artsthat fa l lb e hin dth e c am e ra  from  tr iangles  that arepar tl y in front a n dpartly beh ind  — becomes a n e xpense  t o d o  away  wi th. A  lot o f  title s just de le t e anyt riangle c om plet ely behind the ca m er a , keep any who lly in  f r on t ,  an d f rom the ot he rs su b dividet oa p oin t  but then jus t push thev ert ices t ha t s h ould b e beh in d  to  just in fr ont.  Mathemat ically they sh o uld becalcul ati ngbran d  n ew  ge om e try th ati s e xactly c ut  b y the  cam e r a .  Tha t a ddsa sor t of liquid e ffe ct,w her e cam era m otio nsligh tly de forms  n ear geometry by  com pressingitan d m ov ing i t  aroun d.So:  the ve ry near geo me t r y  c an be slightly adj us t e d,  and the  pixel co nt e nts of e ac h t rian g l e are  ine x ac t.
There 's als o  a  l ack ofsu bpixel  p rec isi on th a t fu rtherreducespreci s ion at triangl e  edges and mo r es u bt l y wi thi n their fil ls.T he i ssue th ere is th at th ev er t ices the describe t he  bound ary o f a triangleare stored a s  integer s, p r ec i se only to the  near est wholep ixel. Th at'senough i nformatio n to locat e t hem  ex act l y  b ut it affects h ow p re ciselyyou  can ca lcu lat e t heon -screen p ositions  o fal loth er ed g e pixels ,and  h owwelly ou can  mapback  f ro m  th e scree n  t o theso ur ce t ext ur e whe n fi l lin g in th e middle. 
Fo r  exa mp le , imagi ne a triangle  e dge that b eg ins  in th e pixel at  (x, 0) and ends in the pixel a t ( x+1,100) . You kno w d efinit ely whichcolumn  thest art i n g pix e l  m ust  b e in. Youk n owdefin it elywhich c olumn the ending p i xel  should be in . B ut e x a ct lyw he r e s ho u ldy o u switch column ? Whatever  c h oi ce you mak e , i t' s going  to beexact l y the s ame for e very fram ewher e the  start and  end ver tices fal l  at t h os e two  lo cation s.  Bu t wha t if t h e c amera  is pa nn ing ve ry sl ow ly, and,  say, every sixth frame  the e dge m ove s one pix elt o t he left?With out subpix elacc uracy , t h e ent iree dg e w i ll ap pear to be sta t ic  fo r si x frames an d t hen  sudd enl y  leap.  Sup posing everything else on screen  isn ' t  mo vin g  atex actly the same  ra te , it'll ap pe ar not to m ove enti re l y wit h thescene.  There' s an overal l sh aki ness, asthe  v a rious d if fe r ent ve rtic es  all j ump fr o m on e pixel to the nex t atd i ffere n t t imes,  m aking i t  loo k like som e frames ar e upda ting  some  part o fthe di spl ay , other fr a mes are u pdati ng othe rs  eve n t houghever y singl e pi xe l w as drawnf o re ve ry sin gleframe .If i nstead yo u  knew th aty ou were  d raw i n g from ,  s a y , (x + 0.1 , 0 ) to( x  + 1.3, 10 0 ) in on e  fram e
 subdivide_larger triangles_as they get closer_to the_camera.
But_then clipping_the_geometry — discarding_those parts that_fall behind the camera_from triangles that_are_partly in front and partly behind — becomes an expense to do away with._A_lot of_titles_just_delete any triangle completely behind_the camera, keep any wholly_in front,_and from the others subdivide to a point_but_then just push_the vertices that should be behind to just in_front. Mathematically they should be calculating_brand new geometry_that_is_exactly cut by the_camera. That adds a sort of_liquid effect, where camera motion slightly_deforms near geometry by compressing it and_moving it around.
So: the very near_geometry can be slightly adjusted,_and the_pixel contents of each triangle_are inexact.
There's also_a lack_of subpixel precision_that further reduces precision at triangle_edges and more_subtly within their fills. The issue_there_is that the_vertices_the_describe the_boundary of a_triangle_are stored_as_integers, precise only to the nearest_whole_pixel. That's enough information to locate them_exactly but it affects_how_precisely you can calculate_the on-screen positions of all_other edge pixels, and how well_you can_map back_from the screen to the source texture when filling in the_middle.
For example, imagine a triangle edge_that begins in the_pixel at_(x,_0) and ends_in_the pixel_at (x+1, 100). You know definitely which_column the_starting pixel must be in. You_know definitely which column_the_ending pixel should be in. But_exactly where should you switch column?_Whatever choice you make, it's_going_to_be exactly the same for_every frame where the start and_end vertices fall_at those two locations. But what if_the_camera is panning very slowly, and,_say,_every sixth frame the edge moves_one_pixel_to the left? Without subpixel_accuracy, the entire edge will appear_to be static for six frames and then suddenly_leap. Supposing everything_else on screen isn't moving_at_exactly_the same rate, it'll appear not to move entirely with_the scene._There's an overall_shakiness, as the various different vertices all jump from one_pixel to the next at different times,_making it look like some frames are updating some part of_the display, other frames are updating others even_though every single pixel was drawn for_every single frame.
If instead_you_knew that you were drawing from, say,_(x_+_0.1,_0) to (x_+ 1.3, 100)_in one frame