CS179: GPU Programming Recitation 5: Rendering Fractals

Transcription

1 CS179: GPU Programming Recitation 5: Rendering Fractals

2 Rendering Fractals Volume data vs. texture memory Creating and using CUDA arrays Using PBOs for screen output Quaternion Julia Sets Rendering volume data

3 Volume Data Stored in global memory Can be accessed only as linear memory No texturing pipeline features available But, only form of global writeable data Allocate arbitrary linear memory using cudamalloc

4 Texture Memory CUDA arrays allocated in texture memory Then declare texture in device: use cudamalloc3darray for correct pitch texture<float, 3, readmodeelementtype> tex; <type, dimensions, readmode> type = cudareadmodeelementtype cudareadmodenormalizedfloat Access using tex3d: tex3d(tex, s, t, p);

5 Textures Can set properties of existing tex object: tex.normalized = true; tex.filtermode = cudafiltermodelinear; tex.addressmode[i] = cudaaddressmodeclamp; Basically, same settings as OpenGL Then, bind tex using Malloc3D's array: cudabindtexturetoarray No need to bind/unbind for each use Usually have at least 8 texture lines available Probably wont need more than one anyway...

6 Using PBOs How to actually render using CUDA? PBO: pixel buffer object A PBO handles pixels like VBOs handle vertices OpenGL allocates it as a region of global memory So, it can be mapped via cudaglmapbufferobject written to by CUDA bound using glbindbufferarb GL_PIXEL_UNPACK_BUFFER_ARB then drawn to screen with gldrawpixels

7 Lab 5 Rendering quaternion Julia sets Not as complicated as it sounds: Calculate volume fractal using equation Copy over to texture memory Volume render Only recalculate when necessary But first.. what is a quaternion Julia set?

8 Fractals Self-similar, recursive sets Became popular in mid-late 1900s with the evolution of graphics Difficult before graphics due to infinite detail Graphics made visualizing them possible Mandlebrot used fractals to try and estimate coastlines..

9 The Mandlebrot Set

10 The Mandlebrot Set zn+1 = zn2+c

11 The Mandlebrot Set Defined by iterative complex equation: zn+1 = zn2 + c c is a pixel coord on the complex plane x-axis = real axis, y axis = imaginary axis z0 = 0 Three possible results depending on c: Converge to 0 (black space) Stays in finite orbit (boundary) Escapes to infinity

12 The Mandlebrot Set Typically computed by iterating z and checking if it escapes some magnitude (~2) Can color based on rate of escape Typically iterations is enough to tell behavior of z Used to take seconds to render set on CPU See SDK for real-time program

13 Julia Set Each point of the Mandlebrot set has a corresponding Julia set: Iterate z2 + c, but z0 is some pixel

14

15

16

17 Julia Sets Calculated in the same way as Mandlebrot sets We don't really have a practical application for these.. But they look really pretty! And they're parallelizable, so we'll work with them

18 Quaternion Julia Sets We could do 2D Julia sets.. But 4D ones are more exciting! The iterative process is the same, except now we use Quaternions.

19 Quaternions Extension to the real numbers: 2 2 i = j =k ij=k jk =i ki= j 2 =ijk = 1 ji= k kj= i ik = j Very applicable in CG for 3D rotations, visualizations, etc..

20 Quaternion Julia Sets So, we can create a 4D set, but how do we render in 3D? Projection!

21 Projection We can take 2D slices of a 3D object Think MRI scan Same idea: we take 3D volume slices of a 4D object Imagine a 3D object that morphs over time The object at one instance of time is our 3D slice These 3D slices are what we render So, we have three parameters now: z0, c, and the slicing plane

22 Quaternions in Lab 5 Quaternion multiplication provided: pos_to_quat mul_quat, sqr_quat Given a plane as a parameter, converts a 3D position to a quaternion We'll store quaternions as float4's cutil_math.h provides vector math (dot, cross, etc.) and operator definitions (float4 * float, etc.)

23 Rendering Transform each point in volume texture to quaternion Iterate the Julia fractal equation Store whether point is in set or how fast it escapes Then, use normal volume rendering techniques raytracing.. remember lab2? Raytracing might not work perfectly.. Julia sets have infinite detail, so some parts are infinitely thin

24 Julia Distance Function There is a distance estimator function for Julia Sets Gives lower bound on the distance to the set from any point in space Iterate section equation simultaneously with Julia set equation: zn' = 2znzn' Then, the distance is estimated by: z n d ( z)= log z n 2 z n '

25 Julia Distance Function We can actually just render this function! Distance function is smooth, so we can render the isosurface of it More iterations improve the estimate

26 Julia Distance Function How to use it: Iterate z'n+1= 2znzn' and zn+1= zn2 + c with provided c and z0 Can stop iterating once zn escapes ( zn 2 > ~20) or reach maximum number of iterations Return distance on previous slide

27 Better Rendering Fill in volume data with value of distance function at each point Copy to volume texture Step along projected ray and render when you hit isosurface (value < epsilon) This is pretty fast when parallelized like lab 2

28 Best Rendering But we can speed this up! We have a distance estimator If we estimate we are 0.5 units away, no need to step ray by Step by a * d(z) a is just some constant works well Will this cause thread divergence? Not really, threads that finish early will just wait Note: These distances are in 4D

29 Drawing Isosurface Stop stepping along the ray when we hit surface, and render something In order to do lighting, we'll want the normal For a smooth scalar field, the normal is the gradient of the field at that point Compute gradient from volume texture? No, this will be blocky Instead, compute gradient via more juliadist calls

30 Computing Normals Theoretically, this should work.. But in practice, it doesn't work too well Can also arbitrarily choose axes for gradient computation, then calculate tangent and binormal, then normal = tangent x binormal Still, not too great, but better This is optional, you can just do the gradient, it's much easier

31 Lab 5 What you need to do: On the host: Execute kernels Copy global memory to texture memory Look up necessary functions in CUDA manuals Set symbols in graphics memory On the device: Julia distance estimator function Fractal computation kernel Volume rendering kernel Let the TODOs guide you, as usual

32 Important Note on Registers Volume rendering calls JuliaDist, intersectbox, computes normals, etc. Easy to run out of register memory So, be careful and put things into functions if you don't need them later (helps compiler) Might also want to use less than 512 threads per block

33 Lab 5 What's given to you: Volume render ray is set up Steps along ray at constant interval and accumulates from 3D texture Change this to have a dynamic interval and stop when we hit isosurface

34 Lab 5 Organize your volume cube with threads running in the lowest dimension and a 2D grid for the other 2 dimensions to make indexing easier See globally defined dim3s The space extends in ±2.0 in each direction (for converting indices to positions) 1 thread per element is probably fastest, but feel free to experiment with loops

35 Memory Coalescing If you compute the index within the block as: i = x + width*y + width*height*z then write to output[i] threads run along x, therefore coalesced Non-coalesced case: x swapped with one of the other dimensions Test both coalesced and non-coalesced speeds, write results into README

36 Cool stuff: Color it however you want You should compute normals Color it as a function of something: normals position in space etc.. Could experiment with different functions, like z3 + c (mention it in README)

37 Cool Stuff Extra credit: Raytrace for shadows? Adaptive Detailing: render using lower epsilon if we're closer to camera

38 Final Notes We could just raytrace entire set also pretty fast This way teaches us a little about memory Raytracing also fairly simple Just call JuliaDist in volume rendering function instead of sampling texture But, sampling textures is still faster We get more threads this way (O(n3) instead of O(n2))