-
Notifications
You must be signed in to change notification settings - Fork 0
/
Copy pathREADME
171 lines (120 loc) · 6.49 KB
/
README
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
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
High-Performance GPU Software Rasterization 1.1
-----------------------------------------------
Implementation by Tero Karras and Samuli Laine
Copyright 2010-2012 NVIDIA Corporation
This package contains full source code for the fast GPU-based software
rasterizer described in the following paper:
"High-Performance Software Rasterization on GPUs",
Samuli Laine and Tero Karras,
Proc. High-Performance Graphics 2011
http://www.tml.tkk.fi/~samuli/publications/laine2011hpg_paper.pdf
The source code is licensed under New BSD License (see LICENSE), and
hosted by Google Code:
http://code.google.com/p/cudaraster/
Abstract
--------
In this paper, we implement an efficient, completely software-based graphics
pipeline on a GPU. Unlike previous approaches, we obey ordering constraints
imposed by current graphics APIs, guarantee hole-free rasterization, and
support multisample antialiasing. Our goal is to examine the performance
implications of not exploiting the fixed-function graphics pipeline, and to
discern which additional hardware support would benefit software-based
graphics the most.
We present significant improvements over previous work in terms of
scalability, performance, and capabilities. Our pipeline is malleable and
easy to extend, and we demonstrate that in a wide variety of test cases its
performance is within a factor of 2-8x compared to the hardware graphics
pipeline on a top of the line GPU.
System requirements
-------------------
- Microsoft Windows XP, Vista, or 7.
- At least 1GB of system memory.
- NVIDIA CUDA-compatible GPU with compute capability 2.0 and at least 512
megabytes of RAM. GeForce GTX 480 is recommended.
- NVIDIA CUDA 4.0 or later.
- Microsoft Visual Studio 2010. Required even if you do not plan to build
the source code, as the runtime CUDA compilation mechanism depends on it.
Instructions
------------
1. Install Visual Studio 2010. The Express edition can be downloaded from:
http://www.microsoft.com/visualstudio/en-us/products/2010-editions/visual-cpp-express
2. Install the latest NVIDIA GPU drivers and CUDA Toolkit.
http://developer.nvidia.com/object/cuda_archive.html
3. Run crsample.exe to start the application in interactive mode. The first
run executes certain initialization tasks that may take a while to
complete.
4. If you get an error during initialization, the most probable explanation
is that the application is unable to launch nvcc.exe contained in the
CUDA Toolkit. In this case, you should:
- Set CUDA_BIN_PATH to point to the CUDA Toolkit "bin" directory, e.g.
"set CUDA_BIN_PATH=C:\Program Files (x86)\NVIDIA GPU Computing Toolkit\CUDA\v4.2\bin".
- Set CUDA_INC_PATH to point to the CUDA Toolkit "include" directory, e.g.
"set CUDA_INC_PATH=C:\Program Files (x86)\NVIDIA GPU Computing Toolkit\CUDA\v4.2\include".
- Run vcvars32.bat to setup Visual Studio paths, e.g.
"C:\Program Files (x86)\Microsoft Visual Studio 10.0\VC\bin\vcvars32.bat".
5. Run benchmark.cmd to measure the performance of CudaRaster and OpenGL on
both test scenes with the same settings that were used in the paper.
The script may take roughly 15 minutes to complete. The results are written
into "benchmark.log", and are organized according to the Table and Figure
numbering in the paper. The files "benchmark-gtxXXX-cudaYY.log", included
in the package, contain reference results for different GPUs and CUDA
versions.
6. Optional: Build the application manually.
- Open cudaraster.sln in Visual Studio 2010.
- Right-click the "crsample" project and select "Set as StartUp Project".
- Build and run. Release/Win32 is recommended.
Package structure
-----------------
/crsample.exe Pre-built binary for the sample app.
/cudaraster.sln Visual Studio 2010 solution file.
/benchmark.cmd Script to run the benchmarks.
/benchmark.log Benchmark results.
/<scene>_cam<num>.png Result images.
/benchmark-gtxXXX-cudaYY.log Reference results (GTX XXX, CUDA Y.Y).
/state_crsample_<num>.dat State files, exported with Alt-<num>.
/screenshot_crsample_<code>.png Screenshots, exported with PrtScn.
/scenes/ Test scenes in Wavefront OBJ format.
/cudacache/ Temporary directory for CUDA binaries.
/build/ Temporary directory for VS builds.
/src/cudaraster/ Sources for the rasterizer.
/src/cudaraster/CudaRaster.hpp Host-side public interface.
/src/cudaraster/cuda/PixelPipe.hpp Device-side public interface.
/src/crsample/ Sources for the sample application.
/src/crsample/App.cpp Interactive mode.
/src/crsample/Benchmark.cpp Benchmark mode.
/src/crsample/Shaders.cu Device-side shader code.
/src/framework/ General-purpose utility classes.
Version history
---------------
Version 1.1, May 22, 2012
- Fix incorrect pixel coverage computation with CUDA 4.1 and above.
- Fix incorrect ROP ordering with Kepler-based GPUs.
- Switch to New BSD License (previously Apache License 2.0).
- Upgrade to Visual Studio 2010 (previously 2008).
- Support PNG textures through lodepng.
- Fix a CUDA compilation issue with Visual Studio Express.
- General bugfixes and improvements to framework.
Version 1.0, Jul 08, 2011
- Initial release.
Known issues
------------
- The maximum viewport size is limited to 2048x2048, due to 32-bit fixed
point math used in edge functions and plane equations.
- Subpixel resolution (4 bits) is lower than in the hardware pipeline
(8 bits).
- Attribute precision is also lower. Upper bound for relative error is 2^-15
without multisampling and 2^-12 with 8x MSAA. Depth, however, is very
accurate.
- The overall memory footprint of the current implementation is relatively
high, roughly 90 bytes per triangle in one batch. This can be alleviated
by splitting larger models into multiple batches.
- The frame buffer is limited to 32-bit color and 32-bit depth. Support for
other formats (e.g. float4) may be added in the future.
- The support for mesh and image formats is very limited. In particular,
only Wavefront OBJ meshes and truecolor PNG/TGA/TIFF/BMP textures are
supported. If you have trouble importing a mesh, you may want to try
enabling WAVEFRONT_DEBUG in src/framework/io/MeshWavefrontIO.cpp.
Acknowledgements
----------------
University of Utah for the Fairy model.
Brian Curless and Marc Levoy the Happy Buddha model.