Hardware-Based Visibility Ordering

Transcription

1 Hardware-Based Visibility Ordering Hardware-Assisted Visibility Sorting for Unstructured Volume Rendering and Vis-Sort: Fast Visibility Ordering of 3-D Geometric Primitives

2 Overview Recent changes in hardware programmability k-buffer: A fragment stream sorter Hardware-Assisted Visibility Sorting Dynamic Level-of-Detail Current research Vis-Sort

3 GPU: Recent Features Render to texture Why? Better performance Applications Dynamic textures Multi-pass algorithms Image processing

4 GPU: Recent Features Multiple Render Targets (MRTs) Write into multiple textures simultaneously [NVIDIA]

5 GPU: Recent Features OpenGL Pixel Buffers (PBuffers) Enables off-screen rendering Contains its own depth, stencil, and aux buffers MRT support by rendering into Front and up to 3 AUX buffers

6 GPU: Recent Features Disadvantages of PBuffers Each has its own OpenGL context Switching between PBuffers is expensive Cannot share buffers between PBuffers Pixel format selection Extensions only available on Windows

7 GPU: Recent Features OpenGL Framebuffer Objects (FBOs) A collection of attachable textures Color, depth, stencil, etc. Attached textures are source and destination for fragment shaders MRTs are available using multiple color attachments

8 GPU: Recent Features Advantages of FBOs A single context Pixel format determined by texture format Share buffers between FBOs Easier to use than PBuffers Works on multiple platforms

9 GPU: Recent Features Code PBuffers RenderTexture 2.0 (Mark Harris) FBOs Framebuffer Object Class (Aaron Lefohn)

10 Sorting Application Object-Space Sorting Rasterization Image Space Display

11 Object-Space Sorting A B C E D F B < A A < C B < E C < D C < E E < F D < F Viewing direction [Williams]

12 Sorting Application Object-Space Sorting Rasterization Image Space Display

13 Image-Space Sorting [Carpenter]

14 Sorting Application Object-Space Sorting Rasterization Image Space Display

15 k-buffer Fixed-size A-Buffer As a new pixel is inserted, another is removed Can efficiently sort a k-nearly Sorted Sequence (k- NSS) [Callahan et al. 05]

16 k-buffer input k-buffer output

17 k-buffer input k-buffer 1 output

18 k-buffer input k-buffer 1 3 output

19 k-buffer input k-buffer 3 2 output 1

20 k-buffer input k-buffer 3 4 output 1 2

21 k-buffer input k-buffer 4 6 output 1 2 3

22 k-buffer input k-buffer 6 5 output

23 k-buffer input k-buffer 6 output

24 k-buffer input k-buffer output

25 Object-Space Sorting Performed on CPU Sort faces by center Least Significant Digit Radix Sort Handles floating-point numbers inline unsigned int float2fint (unsigned int f) { return f ^ ((-(f >> 31)) 0x ); } Results: 15 million faces/sec

26 Image-Space Sorting Performed on GPU Uses k-buffer as a fragment stream sorter Keeps k entries per pixel, each entry contains a fragment s scalar value and distance from the viewpoint (v,d) An incoming fragment replaces the entry that is closest to the eye (front-to-back compositing)

27 Hardware-Assisted Visibility Sorting Sort in image-space and object-space Approximate sort in object-space Complete sort in image-space

28 k-buffer In Hardware Texture 1 Texture 2 Texture 3 Texture 4 r comp g comp b comp a comp v 1 d 1 v 2 d 2 v 3 d 3 v 4 d 4 v 5 d 5 v 6 d 6

29 k-buffer in Hardware

30 Details Fix incorrect texture coordinates caused by perspective-correct interpolation Perspective Correct Projecting vertices to find tex coords Projecting tex coords in shader

31 Details Simultaneously reading and writing to a texture is undefined when fragments are rasterized in parallel

32 Details Initialization and Termination Non-convex objects

33 Experiments Environment 3.2 GHz Pentium MB RAM Windows XP ATI Radeon 9800 Pro Results k-buffer analysis Performance results

34 k-buffer Analysis Dataset Max A Max k k > 2 k > 6 Spx , Torso ,317 1,683 Fighter Accuracy Analysis k depth required to render datasets Max values from 14 fixed viewpoints

35 k-buffer Analysis Distribution Analysis Shows the actual pixels that require large k depths to render correctly k 2: green 2 < k 6: yellow k > 6: red

36 Results Dataset Cells k = 2 fps k = 2 tets/s k = 6 fps k = 6 tets/s Spx2 0.8 M K K Torso 1.1 M K K Fighter 1.4 M K K GPU Sorting Performance viewport with a pre-integrated lookup table

37 Results Dataset Cells CPU GPU Total Tets/s Spx2 0.8 M 160 ms 368 ms 528 ms 1568 K Torso 1.1 M 210 ms 390 ms 600 ms 1805 K Fighter 1.4 M 268 ms 505 ms 773 ms 1816 K Total Performance CPU sorting + GPU sorting and compositing Pipeline optimization = max(cpu, GPU)

38 Movie

39 Movie

40 Conclusion Introduced the k-buffer and an efficient GPU implementation Fastest volume renderer for unstructured data Can handle arbitrary non-convex meshes Requires minimal pre-processing of data Maximum data size is bounded by main memory Code is short and simple Requires no neighbor information

41 Dynamic Level-of-Detail 100% 2.0 fps 25% 5.3 fps 5% 16.1 fps [Callahan et al. 05]

42 Time Varying Scalars [Bernardon et al. 06]

43 irun 5) #AMERA.ODE 3ORTER 0REDICTED #AMERA A 'EOMETRY #ACHE #ACHED 'EOMETRY 6ISIBLE.ODES &RUSTUM #ULLING B 4RIANGLE 3ORTER 3ORTED &ACES,/$.ODES,/$,OOK!HEAD 3ORTED.ODES 'EOMETRY &ETCHING 1UEUE 2EQUESTED.ODES &ETCHING 4HREAD &RAGMENT 3ORTER )MAGE $ISK 2EAD.ODES C D [Vo et al. 06]

44 3,.(,0-&)(&3-1&3,.(,0-&02(;.7,>&& 02(;.7,0&+3&.&07,3,>&&G,&6,-&=)-1&-1,&4,*-1&.34&7)5)(&HIJK%L&+3;)(9.-+)3&;)(&,.71&5./,(>& Depth Peeling?1,&+9.6,0&D,&6,-&;()9&*,,5+36&.D./&4,*-1&.(,&01)D3&+3&E+62(,&M>&&#-&7.3&=,&82+-,& 7)3;20+36&-)&9.:,&0,30,&);&-1,&+9.6,0&);&5./,(&N&.34&=,/)34B&=,7.20,&-1,&3)-+)3&);&.& -,.*)-&+0&(,34,(,4&D+-1&-D)<0+4,4& &H)2-0+4,&+0&(,4&.34&+30+4,&+0&6(,,3LB&.34&-1,& 6()234&*5.3,&+0&4(.D3&+3&=52,>&&!)-,&-1.-&-1,&+9.6,&5.=,5,4&QR./,(&FS&+0&+3&-1,&01.*,&);&.& -,.*)-B&=2-&9)0-&);&-1,&;(.69,3-0&+3&-1.-&5./,(&.(,&;()9&-1,&6()234&*5.3,&H-1,/&.(,&=52,L>&& G+-1)2-&-1,&7)5)(+36B&-1+0&D)254&=,&4+;;+725-&-)&+3-,(*(,->& R./,(&T& R./,(&F& R./,(&N& R./,(&M& Figure 1: Volume rendering using depth peeling. Three pairs we show the pixels that have active intersections to be perfor a partial image after the rays corresponding to those intersec the current component). naturally leading to a technique that scales well over time algorithm only handles convex meshes. (i.e., it is not able t temporarily), and they use a technique originally proposed by Figure 1: Volume rendering using depth Three of images are shown. right of thepeeling. mesh, and thepairs markings of exterior cellsonasthe imagina we show the pixels that have activeunfortunately, intersections to be performed on the current pass. On the m le convexification of unstructured meshes has a partial image after the rays corresponding to those intersections have been terminated (i.e., th currently unsolved) problem. We point the reader to Comb the current component). results, Weiler et al. manually convexified the meshes. In this paper, we propose a novel hardware-based ray ca!"#$%&'()''*+&,&'"-.#&,'"//$,0%.0&',"-1/&'2&10+'1&&/"3#)''4.5&%'6',+78,'0+&'3&.%&,0'2&10+,9' turedscales meshes. on the of spe We naturally leading to a technique that wellour overwork timebuilds as GPUs getprevious faster. work Strictly /.5&%':',+78,'0+&',&;732'2&10+,9'.32',7'73)''*87<,"2&2'/"#+0"3#''8"0+'="="2';7/7%"3#'",'$,&2' nificant(i.e., ways. algorithm is based on the algorithm only handles convex meshes. it isour notrendering able to find the re-entry of rays thatwork lea 07'+&/1'2",0"3#$",+'0+&',$%>.;&,)' for a hardware implementation, since, as shown later, we ca temporarily), and they use a technique originally proposed by Williams [15] that calls for the con Figure 1: Volume rendering using depth peeling. Three pairs of images are shown. On the right of each pair, the ordered of so fragments front bounda of the mesh, and the markings oferate exterior cells assequence imaginary they canforbethe ignored during we show the pixels that have activeunfortunately, intersections to be performedof onunstructured the current pass. Onhas the many left, we show implemented in hardware [3, 7]. Our technique shares with convexification meshes unresolved issues that make it!"#$#%&'()*(+,-.(/& a partial image after the rays corresponding to those intersections have been terminated (i.e., they have left is GPU-based, but it subsumes their technique in that we ca currently unsolved) problem. We point the reader to Comba et al. [2] for details. For their e the current component). [Everitt 01, Bernardon et al. 05]

45 Depth Peeling!"#$%1&'($1)*+,-./0010($1223$ 4$ $ 561/#$5"6"#$7+!!1#$! 2$&$1$8$9$! 3$&$%12:3$8$9$ $ ;1.<=$+*><$!?$ $ $ >!%1$&&$'3$ $ $ $ ;>0/761$;1.<=$<10<$ $ $ 1601$ $ $ $ 1*/761$;1.<=$<10<$ $ $ 7>*;$7+!!1#$2$ $ $ ;>0/761$;1.<=$@#><10$ $ $ 01<$;1.<=$!+*5$<"$ABCDECB$ $ ;1.<=$+*><$"?$ $ $ 7>*;$7+!!1#$3$ $ $ 561/#$;1.<=$7+!!1#$ $ $ 1*/761$;1.<=$@#><10$ $ $ 1*/761$;1.<=$<10<$ $ $ 01<$;1.<=$!+*5$<"$FCGG$ $ #1*;1#$051*1$ $ 0/H1$5"6"#$7+!!1#$BAID$/0$6/J1#$1$ K$ M./,(&P& M./,(&O& M./,(&Q& P&&&&&&&&&&&&&5,*-;&&&&&&&&&&&&&O& P&&&&&&&&&&&&&5,*-;&&&&&&&&&&&&&O& P&&&&&&&&&&&&&5,*-;&&&&&&&&&&&&&O& [Everitt 01]

46 Nearly Sorted Sequences Knuth s measure of disorder: Given an input I, the measure of disorder is defined as the minimal number of elements that need to be removed so that the rest of the sequence is sorted. Vis-Sort is O( Y n), where Y is the set of disordered elements

47 Vis-Sort 1D Definitions: I = the input list of elements for the sorting algorithm S = the output list of elements in sorted order M = the monotonically increasing sequence computed in each iteration, where M I [Govindaraju et al. 04]

48 Vis-Sort 1D 1D SORT 1 I = Unsorted input, S ={} 2 while (I is not empty) Begin Iteration: 3 do 4 M = ComputeIncSeq(I) 5 {I,S} = ComputeRanks(I,M,S) 6 end do End Iteration: 7 return S ALGORITHM III.3: COMPUTERANKS(I, M, S) Second Pass: 1 min= 2 T = I 3 for each element x i I, i = 1,..., sizeof(i) 4 if (x i M and x i < min) 5 remove x i from T, and append it to the end of S 6 if (x i T) 7 if x i min, min = x i 8 end for 9 I = T 10 return { I,S} COMPUTEINCSEQ(I) First Pass: 1 min=, M={} 2 for each element x i I, i = sizeof(i),..., 1 3 if (x i min ) 4 add it to the beginning of M 5 if x i min, min = x i 6 end for 7 return M ALGORITHM III.1: Algorithm to compu

49 Vis-Sort 1D I M S Max = Iter = 1

50 Vis-Sort 1D I M S Max = 3 Iter = 1

51 Vis-Sort 1D I M S 1 2 Max = 3 Iter = 1

52 Vis-Sort 1D I M S 1 2 Max = Iter = 2

53 Vis-Sort 1D I 6 M S Max = 6 Iter = 2

54 Vis-Sort 1D I 6 M 6 S Max = Iter = 3

55 Vis-Sort 1D I M 6 S Max = 6 Iter = 3

56 Vis-Sort 3D 3D Sort 1 M={}, I= Unsorted input, S={} 2 while(i is not empty) 3 do First Pass: 4 Clear the depth buffer 5 for each element x i I, i = sizeof(i),..., 1 6 if (x i / M) 7 Render x i using an occlusion query 8 if x i is fully visible, add it to the beginning of M 9 render x i 10 end for Second Pass: 11 T = I, M sub = {}, clear the depth buffer 12 for each element x i I, i = 1,..., sizeof(i) 13 if (x i M) 14 Render x i using an occlusion query 15 if x i is fully visible, remove x i from M and T, and append it to the end of M sub 16 if (x i T) render x i 17 end for 18 I = T, S = S M sub 19 end do 20 return S ALGORITHM IV.1:

57 Cycles If the size of I does not change after a few iterations, there is a cycle Solution: split triangles

58 Multi-Stage Ordering Sort objects (simplicial complexes) by bounding box with Vis-Sort Use local visibility sort for triangles in an object

59 Applications Order-Independent Tranparency Compute back-tofront Use results of previous pass as NSS of next Fig. 4. These images demonstrate the performance of our visibility ordering algorithm on a CAD model with 820K triangles and high depth complexity. The left image shows the original model rendered with opaque objects. The outer walls and structures (represented with

60 Applications N-Body Collision Culling Return a list of potentially intersecting objects Refine this list from multiple viewpoints

61 Advantages Simple and applicable to all 3D models Works on dynamic scenes and exhibits almost linear time performance when there is a high degree of coherence present between successive input sequences It can be easily implemented using occlusion queries on current graphics processors

62 Limitations Input objects have to be non-overlapping with sorted order Cycles are not handled Image level comparisons of object order are not exact