Virtual texturing in software and hardware final

Edit this text to create a Heading 

� This subtitle is 20 points 

� Bullets are blue 

� They have 110% line spacing, 2 points before & after 

� Longer bullets in the form of a paragraph are harder to 

read if there is insufficient line spacing. This is the 

maximum recommended number of lines per slide 

(seven). 

� Sub bullets look like this


Virtual Texturing in Software and Hardware 


� Bullets Monday, are blue 6 August, 2:00pm - 3:30pm 


Juraj Obert 

� Longer bullets in the Advanced form Micro of a Devices paragraph are harder to 

read if there is insufficient J.M.P. van line Waveren spacing. This is the 

id Software 


(seven). 

� Sub bullets look like this 

Graham Sellers 

Advanced Micro Devices

Edit Agenda this text to create a Heading 

�� This Introduction subtitle to Virtual is 20 Texturing points 

�� Bullets Software are Virtual blue Textures (Megatexture) in RAGE 

�� They Partially have Resident 110% Textures line spacing, (PRTs) 2 points before & after 


� OpenGL sparse texture extension 


� Demo (RAGE running PRTs) 


� (seven). Conclusion & Discussion 


3


This slide has a 16:9 media window 


� Bullets Introduction are blue to Virtual Texturing 


Juraj Obert 

� Longer bullets in the Advanced form Micro of a Devices 

paragraph are harder to 



(seven). 


Edit Virtual this Texturing text to create a Heading 

�� This Non-virtual subtitle textures is 20 points 


� One (or multiple) physical textures per game object 


� Game needs to bind them all before a draw call 




(seven). 


5


�� This Virtual subtitle textures is 20 points 



� Only one texture needs to be bound at any given time 


� read Problem if there is insufficient line spacing. This is the 

maximum � The texture recommended cannot possibly number fit into video of memory lines per slide 

(seven). 

� One massive virtual texture that contains data for the entire world 

� E.g., some RAGE virtual textures are 128K x 128K texels (64 GB) 


6


�� This Paging subtitle is 20 points 


� Making only a part of the virtual texture resident in GPU memory 


� Tile (page) granularity 



� Working set – the set of texture tiles resident in GPU memory 


� Represented as another physical texture in GPU memory 

(seven). 

� Orders of magnitude smaller than the virtual texture (needs to fit in GPU memory) 


� Application decides based on FOV, map location, view direction, etc. 

7



� Bullets � Virtual texture are blue subdivided into tiles (pages) 





(seven). 

� Sub Virtual bullets texture look like this 

Images courtesy of Sean Barrett 

8



� Bullets � Tiles uploaded are blue into the physical texture 





(seven). 

� Sub Virtual bullets texture look like this Physical texture 


9


�� This Virtual subtitle texture coordinates is 20 points are mapped to physical texture coordinates through 

� Bullets a page table are texture blue 





(seven). 

� Sub Virtual bullets texture look like this Physical texture 


10

Edit Partially this Resident text to create Textures a Heading – Shader 

�� This SVT texture subtitle lookup is 20 points 

uniform sampler2D samplerPageTable; 

�uniform Bullets sampler2D are samplerPhysTexture; blue 

// page table texture 

// physical texture 

in vec4 virtUV; // virtual texture coordinates 

�out They vec4 color; have 110% line spacing, 2 // points output color before & after 

�vec2 Longer getPhysUV(vec4 bullets pte); in the form of a paragraph // translation are function harder to 

void main() read if there is insufficient line spacing. This is the 

{ 

vec4 pte = texture(samplerPageTable, virtUV.xy); // 1 


vec2 physUV = getPhysUV(pte); 

(seven). 

// 2 

} 

color = texture(samplerPhysTexture, physUV.xy); // 3 


11


�� This Software subtitle virtual is 20 textures points 

� Bullets � Powerful are tool to blue handle massive datasets 

� They � Simple have in theory, 110% but hard line to implement spacing, efficiently 2 points before & after 




(seven). 


12




� Bullets Software are blue Virtual Textures in RAGE 


J.M.P. van Waveren 

� Longer bullets in the form id Software 

of a paragraph are harder to 



(seven). 


Edit Virtual this Textures text to create in Software a Heading 

�� This Motivation subtitle is 20 points 


� Address Translation 


�� Longer Texture bullets Filtering in the form of a paragraph are harder to 



(seven). 


14

Edit RAGE this text to create a Heading 







(seven). 


15

Edit RAGE this text to create a Heading 







(seven). 


16

Edit Unique this Texture text to create Detail a Heading 

�� This Desire subtitle for unique is detail 20 points at a distance and up close. 




� Tiling looks bad at a distance. 


� Bilinear magnification looks bad up close. 


� (seven). Hunger for truly unique detail results in huge texture data set. 

� Texture mapping efficiently adds surface detail to geometric primitives. 

� Tiling, blending and decals are forms of manual texture compression. 


17

Edit Key Observations 

this text to create a Heading 

�� This Massive subtitle amount is of 20 texture points data and only so much physical memory. 

�� Bullets GPU compression are blue formats designed for rendering performance. 



� Lossy compression is perfectly fine for many use cases. 


� Only small subset of texture data needed at any time. 


� (seven). Temporarily fall back to slightly blurrier texture data without stalling 

� Texture data can be stored highly compressed on secondary storage. 

execution � Sub bullets (trade look quality like vs. this performance). 

18

Edit Virtual this and text Physical to create Texture a Heading Data 

�� This Massive subtitle amount is 20 of texture points data in a virtual address space. 

� Bullets � Possibly are highly blue compressed in non-renderable format. 

� 

� 

They have 110% line spacing, 2 points before & after 

Smaller resident subset in a physical address space. 


� Possibly compressed in a GPU renderable format. 


� 

maximum 

Translate virtual 

recommended 

texture addresses 

number 

to 

of 

physical 

lines per 

addresses. 

slide 

(seven). � Various address translation schemes can be applied. 


19

Edit Address this text Translation to create Options a Heading 

� Per Model. 

� This � LOD subtitle system where is each 20 geometry points LOD has its own texture LOD. 

� Make a different texture resident for each LOD. 


� Per Vertex. 

� They � Modify have the geometry 110% texture line coordinates spacing, at run-time. 2 points before & after 

�� Longer Per Fragment. bullets in the form of a paragraph are harder to 

� Translate the texture address per fragment (or per texture lookup). 

read � Unwrap if there all UV islands is insufficient onto one very large line texture. spacing. This is the 

maximum � Divide this large recommended texture into pages that number are made resident of lines as needed. per slide 

� Virtual texture pages map to physical texture pages. 

(seven). 

� Use address translation to map virtual addresses to physical ones. 

� Per � Sub Point bullets Sample. look like this 

� Filtering in software is rather expensive. Need hardware support! 

20

Edit ClipMap this text to create a Heading 

�� This Back in subtitle the day is required 20 points hardware support. 

�� Bullets Can easily are be blue implemented on programmable graphics hardware. 

�� They Texture have sub-square 110% resident line spacing, around single 2 points focus before point on & texture. after 



� No page table needed! 


� (seven). Limited to environments with natural spatial correlation between 

� Single region of interest significantly simplifies the address translation. 

texture � Sub data bullets and look geometry. like this 

21

Edit Flexible this Address text to create Translation a Heading 


� Bullets and texture are data. blue 

�� They Need more have flexible 110% texture line spacing, management 2 points and address before translation. & after 

�� Longer Need to map bullets arbitrary in the virtual form texture of a pages paragraph to physical are memory. harder to 



(seven). 

� Not all environments have a natural correlation between the geometry 


22

Edit Virtual this Textures text to create in RAGE a Heading 







(seven). 


23








(seven). 


24








(seven). 


25








(seven). 


26








(seven). 


27








(seven). 


28








(seven). 


29








(seven). 


30








(seven). 


31








(seven). 


32








(seven). 


33








(seven). 


34








(seven). 


35








(seven). 


36








(seven). 


37








(seven). 


38








(seven). 


39








(seven). 


40

Edit Page this Tables text to create a Heading 



�� They One scale have value 110% if virtual line and spacing, physical 2 textures points are before square. & after 


� Two scale values if using non-square virtual or physical texture. 


� Two bias values to map virtual pages to arbitrary physical pages. 


(seven). 

� Scale is ratio between virtual mip level size and physical texture size. 

� The bias is offset to physical page minus scaled offset to virtual page. 


41

Edit Page this Tables text to create a Heading 

� Quad-tree 


� Minimal memory footprint. 

� Bullets � Quad-tree are updates blue are cheap. 

� Dependent lookup for each level accessed. 

�� They Hash table have 110% line spacing, 2 points before & after 

� Longer � Small memory bullets footprint. in the form of a paragraph are harder to 

� Hash table updates are relatively cheap. 

read � Need if multiple there lookups is when insufficient the desired page is line not resident. spacing. This is the 

� maximum Page table texture recommended number of lines per slide 

� Allows texture hardware to be used to directly find the scale & bias for a virtual address. 

(seven). 

� Larger memory footprint because it effectively stores the full quad-tree whether pages are resident or not. 


� Texels for pages that are not resident point to the nearest coarser resident page. 

� May need to update large squares of texels when a page is mapped or unmapped. 

42

Edit Page this Table text Textures to create a Heading 

� Store complete quad-tree as a mip-mapped texture. 


� Store full FP32x4 with scale and bias. 

� Bullets � Encode are scale blue and bias into UINT16x4. 

�� They Use a page have table 110% plus line mapping spacing, texture 2 to points store the before scale and & after bias. 

� Longer � Store 8:8 bullets page table in texture the with form 1 texel of per a virtual paragraph page. are harder to 

� Store FP32x4 mapping texture with 1 texel per physical page. 


� Calculate the scale and bias in a fragment program. 


� Store physical page coordinates and base-two logarithm of mip-level width in pages. 

(seven). 

� 8:8:8:8 = X:8 + Y:8 + W:16 

� 5:6:5 = X:5 + W:6 + Y:5 


� Pre DX10 hardware has different conversions from 8-bits to FP32. 

43

Edit Texture this Filtering text to create a Heading 

� Bilinear filtering without borders 


� Adjacent virtual pages are not necessarily adjacent in the physical texture. 

� Bullets � Clamp at are border blue causes objectionable seams at mip level transitions. 

�� They Bilinear have filtering 110% with borders line spacing, 2 points before & after 

� Need at least a 1 texel border. 


� Trilinear filtering with borders. 

read � Mip if mapped there physical is insufficient texture. line spacing. This is the 

� Two address translations. 


� Anisotropic filtering with borders. 

(seven). 

� 4-texel border (max aniso = 4) 

�� Sub Explicit bullets derivatives look + TXD like (texgrad) this 

� Using implicit derivatives work surprisingly well! 

44

Edit Anisotropic this text Texture to create Filtering a Heading 

� Page table is point sampled. 


�� Bullets Page table are lookup blue unaware of anisotropic lookup that follows. 

�� They May end have up with 110% a page line that spacing, is too coarse. 2 points before & after 

�� Longer Not enough bullets texture in detail the for form the of anisotropic a paragraph texture are filter. harder to 

� read Bias the if there page table is insufficient lookup based line on the spacing. anisotropic This footprint. is the 


(seven). 


45

Edit Anisotropic this text Page to create Table a Bias Heading 

float minAnisoBias = -2; // - log2( maxAniso = 4 ) 


� Bullets float2 dx are = ddx( blue virtualTexCoords.xy ); 

float2 dy = ddy( virtualTexCoords.xy ); 


� Longer float px bullets = dot( dx, in dx the ); form of a paragraph are harder to 

float py = dot( dy, dy ); 



float maxLod = 0.5 * log2( max( px, py ) ); // log2(sqrt()) = 0.5*log2() 

(seven). 

float minLod = 0.5 * log2( min( px, py ) ); 


float anisoBias = max( minLod - maxLod, minAnisoBias ); 

46

Edit Software this text Virtual to create Texture a Heading Issues 

� Memory cost 


� Page table textures can take up a fair amount of memory. 


� Performance cost 


� Dependent texture lookup(s) for address translation. 


� read Texture if filtering. there is insufficient line spacing. This is the 

� Various trade-offs. 


� High quality filtering is still costly. 

(seven). 


47




� Bullets are Partially blue Resident Textures 


Juraj Obert 





(seven). 


Edit Partially this Resident text to create Textures a Heading 

�� This Memory subtitle requirements is 20 points determined by the number of 

� Bullets resident are tiles, blue not texture dimensions 




maximum recommended number of Non-PRT lines per PRT slide 

(seven). 

Memory 4096 kB 1536 kB 


RGBA8, 1024x1024, 64 tiles 

49


�� This PRTs subtitle rely on is 3 20 core points components: 


� They 

� Hardware virtual memory subsystem (HW VM) 

have 110% line spacing, 2 points before & after 


� Shader core feedback 



� SW driver stack 

(seven). 


50

Edit Partially this Resident text to create Textures a Heading – HW VM 

�� This Hardware subtitle virtual is 20 memory points 


� They 

� Latest generation GPUs use virtual addresses 



� Page table in the on-board GPU memory 



� Address translation entirely in hardware 

(seven). 


51


� This subtitle is texture(sampler, 20 points uv); 

� Bullets are uv blue 

data 

virtual physical 

� They have 110% Texture line Unit 

address address 

spacing, 2 points before & after 

… 

� Longer virtual address bullets in the form data of a paragraph are harder to 

read if there is insufficient Memory line spacing. This is the 

Controller 


(seven). physical 

address data 


Physical Memory 

Page Table 

52


�� This Texture subtitle Unit is 20 points 

� Bullets � UV to are virtual blue address translation 

� Hardware filtering 


� Caching 



� Memory Controller 


� Virtual to physical address translation 

(seven). 

� Page table 

�� Sub Caching bullets look like this 

53


�� This SVT texture subtitle fetch is 20 points 

uniform sampler2D samplerPageTable; // page table texture 





�vec2 Longer getPhysUV(vec4 bullets pte); in // the translation form of function a paragraph are harder to 


{ 



(seven). 

} 


54



� Bullets are virtUV blue 

PTE 





… 



Controller 



address data 



Page Table 

55











{ 




(seven). 

// 2 

} 


56











{ 




(seven). 

// 2 

} 

color = texture(samplerPhysTexture, physUV.xy); // 3 


57



� Bullets are physUV blue 

color 





… 



Controller 



address data 



Page Table 

58


�� This PRT texture subtitle fetch is 20 points 

�uniform Bullets sampler2D are samplerPRT; blue 

// partially-resident texture 





{ 


color = vec4(0.0); 

(seven). 

} 

texture(samplerPRT, virtUV.xy, color); // 3 


59



� Bullets are virtUV blue 

color 





… 



Controller 



address data 



Page Table 

60


�� This Virtual subtitle address is 20 space points 


� They 

� Segmented into 64 kB tiles (pages) 



� Each tile can be either mapped (resident) 

read or unmapped if there is (non-resident) insufficient line spacing. This is the 


(seven). 

� Mapping/unmapping controller by the 

� Sub application/driver 

bullets look like this 

x x 

x x x x x 

x x x 

x x x x x 

61

Edit Partially this Resident text to create Textures a Heading – NACK 


virtual 

address 

� Bullets are uv blue 

NACK 

� They have 110% Texture line Unit spacing, 2 points before & after 

… 

� Longer virtual address bullets in the form NACK 

NACK 



Controller 


(seven). 



Page Table 

62


�� This NACKs subtitle in shaders is 20 points 

void main() 

�{ Bullets are blue 

vec4 outColor = vec4(1.0, 1.0, 1.0, 1.0); 

� They int code have = sparseTexture(sampler, 110% line spacing, texCoordVert.xy, 2 points outColor); before & after 

� Longer if (code == bullets 0) in the form of a paragraph are harder to 

{ 

// data resident 


gl_FragColor = vec4(outColor.rgb, 1.0); 

} maximum else recommended number of lines per slide 

{ 

(seven). // NACK 

} 

gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0); 

�} Sub bullets look like this 

63


�� This What subtitle can be is sparse? 20 points 

� Bullets � Any tile-aligned are blue sub-rectangle of a texture mipmap level 





(seven). 


64



� Bullets � An entire are mipmap blue level 





(seven). 


65



� Bullets � Any part are of blue any cubemap face (anyone ever used the bottom 

cubemap face for anything useful?) 





(seven). 


66



� Bullets � And any are combination blue of everything just mentioned 



� One limitation 


� Everything needs to be tile-aligned 


(seven). 


67

Edit Partially this Resident text to create Textures a Heading – Driver 

�� This Driver subtitle SW stack is 20 functionality points 


� They 

� Create/destroy partially resident resources 



� Map/unmap individual tiles 



� Back virtual allocations by physical memory 

(seven). 


68


�� This Backing subtitle storage is 20 points 


� They 

� A set of physical allocations managed by the driver 



� The goal is to find balance between the number of 

read resources if there and is unused insufficient physical line memory spacing. This is the 


(seven). 

� Each application has different requirements 


69


0 1 2 3 x 8 9 10 11 x 


16 17 18 19 x 20 21 22 23 x 

12 13 14 15 x 28 29 30 31 x 


x x x x x x x x x x 

� They have 110% 4 line 5 6 spacing, 7 x x x 2 points x x x before & after 

x x x x x x x 24 25 x 

� Longer bullets in x the x x form x x of x a x paragraph 26 27 x are harder to 



maximum recommended 

PRT 

number of lines per slide 

(seven). 

Chunk 1 


Chunk 2 

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 

16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 

70


0 1 2 3 x 8 9 10 11 x 


16 17 18 19 x 20 21 x x x 

12 13 14 15 x 28 29 x x x 



� They have 110% 4 line 5 6 spacing, 7 x x x 2 points x x x before & after 

x x x x x x x 24 25 x 

� Longer bullets in x the x x form x x of x a x paragraph 26 27 x are harder to 



maximum recommended 

PRT 


(seven). 

Chunk 1 


Chunk 2 

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 

16 17 18 19 20 21 x x 24 25 26 27 28 29 x x 

71


�� This Summary subtitle is 20 points 

� Bullets are blue SVTs PRTs 

Address translation Shader code HW page table 





(seven). 


72






Filtering HW + shader code HW only 




(seven). 


73








# read of texture if there fetches is insufficient 2, dependent line spacing. 1 This is the 


(seven). 


74









Supported maximum formats recommended The ones implemented number of lines All supported per slide by HW 

(seven). 


75









Supported maximum formats recommended The ones implemented number of lines All supported per slide by HW 

Supported (seven). texture types The ones implemented All supported by HW 


76




� Bullets are Sparse blue Textures in OpenGL 


Graham Sellers 





(seven). 


Edit OpenGL this Extension 

text to create a Heading 

• GL_AMD_sparse_texture 



• Major design goals: 


� Longer – Minimally bullets invasive in the form to the of a OpenGL paragraph API are harder to 

read – Easy if there to retrofit is insufficient into existing line spacing. application This is the 


(seven). – Plays well with non-sparse textures 

�– Sub Easy bullets fallback look like path this 

78

Edit OpenGL this Extension 


• Most of the same code will work in the 


� Bullets absence are blue of the extension 


�• Two parts to the extension 

Longer bullets in the form of a paragraph are harder to 

read – Update if there to is the insufficient API – 1 line function, spacing. a hand This full is the of 

maximum tokens recommended number of lines per slide 

(seven). 

– Update to the shading language 


79

Edit Example this text Using to Existing create a Heading OpenGL API 

• Use of immutable texture storage 


� Bullets GLuint are tex; blue 

� They have glGenTextures(1, 110% &tex); line spacing, 2 points before & after 

glBindTexture(GL_TEXTURE_2D, tex); 

glTexStorage2D(GL_TEXTURE_2D, 10, GL_RGBA8, 1024, 1024); 


glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 1024, 1024, 

GL_RGBA, GL_UNSIGNED_BYTE, data); 



(seven). 

• Existing OpenGL immutable storage API 


– Declare storage, specify image data 

80

Edit Example this text Using to New create Extension a Heading 

• Use of sparse texture storage 


� Bullets GLuint are tex; blue 

� They have glGenTextures(1, 110% &tex); line spacing, 2 points before & after 

glBindTexture(GL_TEXTURE_2D, tex); 

glTexStorageSparseAMD(GL_TEXTURE_2D, GL_RGBA, 1024, 1024, 1, 


1, GL_TEXTURE_STORAGE_SPARSE_BIT_AMD); 



GL_RGBA, GL_UNSIGNED_BYTE, data); 


(seven). 

• glTexStorageSparseAMD is the one new 


function in the extension 

81

Edit Control this Residency text to create With a Heading Existing API 

• Previous example used glTexSubImage2D 



– Upload sub-region of the texture 


� Longer 

– Physical 

bullets 

pages 

in the 

allocated 

form of a 

on 

paragraph 

demand 

are 

by the 

harder to 

read OpenGL if there driver is insufficient line spacing. This is the 

maximum – Unused recommended pages remain number free of lines per slide 

(seven). 


82


• Allocate disjoint chunks 



glTexStorageSparseAMD(GL_TEXTURE_2D, GL_RGBA, 1024, 1024, 1, 

10, GL_TEXTURE_STORAGE_SPARSE_BIT_AMD); 

� They have glTexSubImage2D(GL_TEXTURE_2D, 110% line spacing, 0, 0, 2 0, 256, points 256, before & after 

GL_RGBA, GL_UNSIGNED_BYTE, data1); 

� Longer glTexSubImage2D(GL_TEXTURE_2D, bullets in the form of 0, a 768, paragraph 768, 256, 256, are harder to 

GL_RGBA, GL_UNSIGNED_BYTE, data2); 



(seven). – Enough storage for two 256x256 regions allocated 


83


• Pass NULL to glTexSubImage2D 




GL_RGBA, GL_UNSIGNED_BYTE, NULL); 


� Longer – Makes bullets pages in the non-resident form of a paragraph are harder to 

read – Driver if there returns is insufficient physical line pages spacing. to the This pool is the 


(seven). 


84

Edit Determining this text Page to create Sizes a Heading 

• Sparse Textures rely on VM subsystem 



– Pages are 64 kilobytes in size on Southern Islands 


� Longer 

– Size 

bullets 

of a page 


in 

form 

texels 

of 

depends 

a paragraph 

on texture 

are harder 

format 

to 

read if BPP there is insufficient Texels line BPP spacing. Tile Width This Tile is Height the 

128 4096 

128 64 64 

maximum 64 recommended 8192 number BC2/3/5/6H/7 of lines 256 per slide 256 

32 16384 

(seven). 16 32768 

8 65636 


64 128 64 

BC1/4 512 256 

32 128 128 

16 256 128 

8 256 256 

85

Edit Getting this Page text to Sizes create from a Heading OpenGL 

• Reuse existing API: glGetInternalFormativ 


� Bullets GLint are page_size_x; blue 

� They have glGetInternalFormativ(GL_TEXTURE_2D, 110% line spacing, GL_RGBA8, 2 points before & after 

GL_VIRTUAL_PAGE_SIZE_{X,Y,Z}_AMD, 

sizeof(GLint), &page_size_{x,y,z}); 


read – Given if there a target is insufficient and format, line spacing. returns the This page is the size 


• (seven). It is not necessary to create a texture to get 

this information 


86

Edit Mipmaps 


• Each LOD requires a 


� Bullets different are number blue of pages 


– Each LOD requires fewer and 


fewer pages 


maximum – Eventually, recommended one LOD does number not of lines per slide 

(seven). fill a page 


– Now what? 

87

Edit Low this Resolution text to create Mipmaps a Heading 

• Eventually, we make all LODs resident 



– Use glGetInternalFormativ to retrieve the lowest 


sparse level for a given target/format 


GLint min_sparse_level; 


glGetInternalFormativ(GL_TEXTURE_2D, GL_RGBA16F, 

maximum recommended GL_MIN_SPARSE_LEVEL_AMD, number of lines per slide 

1, &min_sparse_level); 

(seven). 

�– Sub All levels bullets below look like this reside in the same page 

and share residency 88

Edit LOD this Warnings 


• A per-texture low water mark is included 



– Set this to lowest LOD that’s fully resident 


� Longer 

– When 

bullets 

this is 


hit, 

the 

the 

form 

shader 

of a paragraph 

is signaled 

are harder to 

read – Returned if there is data insufficient is still valid line spacing. This is the 


– Start streaming the next mip 

(seven). 

• Exposed using the glTexParameter API 


89

Edit Setting this the text LOD to create Watermark a Heading 

• Exposed using the glTexParameter API 


� Bullets glTexParameteri(GL_TEXTURE_2D, are blue 

GL_MIN_WARNING_LOD_AMD, 4); 


� Longer – Here, bullets an LOD in the warning form of will a paragraph be returned are to harder the to 

read shader if there if hardware is insufficient attempts line spacing. to access This LOD is the 4 or 

maximum lower recommended number of lines per slide 

(seven). 

• More on residency returns later... 


90

Edit Rendering this text to to a Sparse create a Texture Heading 

• Render to a texture using an FBO 


GLuint prt, fbo; � Bullets are blue 

glGenTextures(1, &prt); 

�glBindTexture(GL_TEXTURE_2D, They have 110% prt); line spacing, 2 points before & after 

glTexStorageSparseAMD(GL_TEXTURE_2D, GL_RGBA, 1024, 1024, 

1, 1, GL_TEXTURE_STORAGE_SPARSE_BIT_AMD); 


glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, 1024, 1024, GL_RGBA, GL_UNSIGNED_BYTE, data); 

glGenFramebuffers(1, &fbo); 

glBindFramebuffer(GL_FRAMEBUFFER, read if there is insufficient fbo); line spacing. This is the 

glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, prt, 0); 


(seven). – Writes to unmapped regions are silently dropped 


91

Edit Reading this text From to a create Sparse a Texture Heading 

• Read data to memory using existing APIs 



– Call glGetTexImage to read entire content 


glGetTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, data); 


read – Bind if there to FBO, is insufficient use glReadPixels line spacing. or This is the 

maximum glBlitFramebuffer recommended number of lines per slide 

(seven). 

glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, prt, 

0); 

glReadPixels(0, � Sub bullets 0, 1024, 1024, look GL_RGBA, like this GL_UNSIGNED_BYTE, data); 

glBlitFramebuffer(0, 0, 1024, 1024, 0, 0, 128, 128, GL_COLOR_BUFFER_BIT, GL_LINEAR); 

92

Edit Restrictions this text (or to create Lack Thereof) 

a Heading 

• Sparse textures have some restrictions: 



– Dimensions of the base level must be integer 


multiples of the page size 


• This means... no sparse textures below this size 


maximum – No buffer recommended textures or “TBOs” number of lines per slide 

(seven). – No depth or stencil textures, nor MSAA textures 


93

Edit Managing this text Failure 

to create a Heading 

• Virtual address space is extremely large 



– It will run out eventually, but it’ll take a while 


� Longer 

– It’s still 

bullets 

possible 


to 

form 

run 

of 

out 

a paragraph 

of physical 

are 

memory 

harder to 

read – glTexSubImage2D if there is insufficient etc., line may spacing. fail This is the 


– Draw calls may fail 

(seven). 


94

Edit Managing this text Failure 


• Physical memory is a limited resource 



– Feel free to create a 4k x 4k x 4k volume 


� Longer 

– Don’t 

bullets 

try to 


make 

the form 

it all 

of 

resident 

a paragraph 

at once! 

are harder to 

• read There if there are is no insufficient sparse line read-backs spacing. This is the 


(seven). – glGetTexImage could read gigabytes of data 

�– Sub This bullets will fail look like this 

95

Edit Sparse this Textures text to create in Shaders 


• Texture type in GLSL is the ‘sampler’ 



• Several types of samplers exist... 


� Longer – sampler2D, bullets in sampler3D, the form of samplerCUBE, 

a paragraph are harder to 

read sampler2DArray, if there is insufficient etc. line spacing. This is the 


• We didn’t add any new sampler types 

(seven). 

– Sparse and normal textures use the same types 


96

Edit Sparse this Textures text to create in Shaders a Heading 

• Read textures using ‘texture’ 



– Built-in function, with several overloads 


gvec4 texture(gsampler1D sampler, float P [, float bias]); 

�gvec4 Longer texture(gsampler2D bullets sampler, in the vec2 form P [, float of bias]); a paragraph are harder to 

gvec4 texture(gsampler2DArray sampler, vec3 P [, float bias]); 

gvec4 read textureLod(gsampler2D if there is insufficient sampler, vec2 P, float line lod); spacing. This is the 

gvec4 textureProj(gsampler2D sampler, vec4 P [, float bias]); 

gvec4 maximum textureOffset(gsampler2D recommended sampler, vec2 P, number ivec2 offset [, of float lines bias]); per slide 

// ... etc. 

(seven). 


– We didn’t add any new overloads 

97

Edit Extending this text GLSL 


• Adding new function overloads is difficult 



– Need to return a status code and a texel 


� Longer 

– Need 

bullets 

user-specified 

in the form 

defaults 


with conditional 

are harder to 

read move if there like is functionality insufficient line spacing. This is the 

maximum – Optional recommended parameters in number existing of overloads lines per slide made 

(seven). this very difficult 


98

Edit Extending this text GLSL to create a Heading 

• Added new built-in functions 



– Return both a status code and texel data: 


int sparseTexture(gsampler2D sampler, vec2 P, inout gvec4 texel [, float bias]); 

int sparseTextureLod(gsampler2D sampler, vec2 P, float lod, inout gvec4 texel); 

�// ... Longer etc. 

bullets in the form of a paragraph are harder to 

read – Most if there existing is insufficient texture functions line spacing. have This a is the 

maximum 

sparseTexture 

recommended 

equivalent 


(seven). 

– Non-sparse textures work with new functions 


99

Edit Extending this text GLSL to create | sparseTexture a Heading 

• sparseTexture returns two pieces of data: 


�int sparseTexture(gsampler2D Bullets are blue sampler, vec2 P, inout gvec4 texel [, float bias]); 


� Longer 

– Texel 

bullets 

data via 


inout 

form 

parameter 


read – Residency if there is status insufficient code line spacing. This is the 


(seven). 


100

Edit Extending this text GLSL to create | sparseTexture 


• Texel data returned in inout parameter 



– If texel fetch fails, old data remains in variable 


� Longer 

– Think 

bullets 

of it as 


a 

the 

CMOV 

form of 

type 

a paragraph 

operation 

are harder to 

• read Return if there code is insufficient is hardware-dependent 

line spacing. This is the 


(seven). – More built-in functions for decoding status codes 


101


• No direct support for ‘default value’ 



– But this can be emulated easily: 


vec4 texel = vec4(1.0, 0.0, 0.7, 1.0); // Default value 


sparseTexture(s, texCoord, texel); 


// On success, texel contains texture data. On failure, it has the shader-supplied 

// default value in it (pinkish magenta here). 


(seven). 


102


• Original functions work on sparse textures 



vec4 texel = texture(s, texCoord); 


� Longer – Return bullets value in for the unmapped form of a paragraph regions undefined are harder to 

read – Useful if there when is insufficient residency line is predetermined 

spacing. This is the 


(seven). 


103

Edit GLSL this | Residency text to create Information a Heading 

• Residency information returned to shader 


�vec4 Bullets texel = vec4(1.0, are 0.0, blue 0.7, 1.0); // Default value 

int code; 


code = sparseTexture(s, texCoord, texel); 


• read Code if there is interpreted is insufficient by line additional spacing. This functions is the 

bool maximum sparseTexelResident(int recommended code); number of lines per slide 

bool sparseTexelMinLodWarning(int code); 

int sparseTexelLodWarningFetch(int (seven). 

code); 


104


• Was texel resident? 



bool sparseTexelResident(int code); 


� Longer 

– Returns 

bullets 

true 


if 

the 

data 

form 

is valid, 


false otherwise 

are harder to 



(seven). 


105


• Was texel resident? 



bool sparseTexelResident(int code); 


� Longer 

– Texel 

bullets 

miss 


is 

the 

generated 

form of 

if 

a 

any 

paragraph 

required 

are 

sample 

harder to 

read is if not there resident, is insufficient including: line spacing. This is the 

maximum • Texels recommended required for bilinear number or trilinear of lines sampling per slide 

(seven). 

• Missing mip maps, anisotropic filter taps, etc. 


106

Edit GLSL this | Low-Water text to create Mark a Heading 

• Did I hit the low-water mark? 



bool sparseTexelMinLodWarning(int code); 


� Longer 

– Occurs 

bullets 

when 


generating 

form of a 

paragraph 

texel requires 

are harder 

data 

to 

read from if there an LOD is insufficient lower than line the spacing. low-water This mark is the 

maximum specified recommended by the application number of lines per slide 

(seven). – This can be a signal to the application to start 

� Sub streaming bullets look more like mip this levels 

107

Edit GLSL this | Low-Water text to create Mark a Heading 

• What LOD caused the warning? 



int sparseTexelLodWarningFetch(int code); 


� Longer 

– sparseTexelLodWarningFetch 

bullets in the form of a paragraph 

returns 

are 

0 if 

harder 

the 

to 

read warning if there was is insufficient not hit line spacing. This is the 


(seven). 


108

Edit Sparse this Textures text to create – Use a Cases 

Heading 

• Drop-in replacement for traditional SVT 



– Almost... maximum texture size hasn’t grown 


�• Longer Extremely bullets large in the texture form of a arrays paragraph are harder to 

read – Only if there populate is insufficient a sub-set line of spacing. the slices This is the 


(seven). – Can eliminate texture binds in some applications 


109

Edit Sparse this Textures text to create – Use a Cases 

Heading 

• Large volume textures 



– Voxels, medical applications 


� Longer 

– Use 

bullets 

maximum 


step 

form 

size 

of a 

as 

paragraph 

‘default’ value 

are harder to 

• read Variable if there size is insufficient texture line arrays spacing. This is the 


(seven). – Create a large array texture 

�– Sub Populate bullets different look like this mip levels in each slice 

110

Edit Future this Work 


• Planning further extension(s) 



– Application-controlled physical pool 


� Longer 

– Map 

bullets 

the same 


page 

form 

multiple 


times 

are harder to 

read – Partially if there resident is insufficient buffers line spacing. This is the 

maximum 

• 

recommended number of lines per slide 

Streaming geometry 

(seven). 

• Lazy allocation for fragment lists 


111




� Bullets are Demo blue (RAGE running PRTs) 


J.M.P. van Waveren 

� Longer bullets in the form id Software of a paragraph are harder to 

read if there is insufficient Graham line Sellers spacing. This is the 

Advanced Micro Devices 


(seven). 


Edit PRTs this in RAGE text to create a Heading 







(seven). 


RAGE with PRTs (Image courtesy of id Software) 

113




� Bullets are blue Discussion 





(seven). 


Edit Conclusion 


�• This Partially subtitle Resident is Textures 20 points 

� Bullets – Hardware are implementation blue of virtual texturing 

• Hardware virtual memory subsystem 


• Shader core feedback 


– OpenGL extension available 



• Developer feedback very important 

(seven). 


115




� Bullets are blue Backup 





(seven). 





(for simplicity, assume on-board memory) 


� Longer � Handled bullets by the in DirectX the form Graphics of a Kernel paragraph subsystem are and harder the to 

read kernel-mode if there is device insufficient driver line spacing. This is the 


(seven). 

� The process of making resources resident in GPU-visible memory 

� Regular, non-PRT, resources (textures, buffers) paged in/out with 

resource granularity 


117

Virtual texturing in software and hardware final

You also want an ePaper? Increase the reach of your titles

Delete template?

Save as template?