NASP/cuda-samples
85
0
Fork 0
mirror of https://github.com/NVIDIA/cuda-samples.git synced 2026-10-25 22:28:17 +08:00
Code Issues Packages Projects Releases Wiki Activity

Apply consistent code formatting across the repo. Add clang-format and pre-commit hooks.

Browse Source
This commit is contained in:
Rob Armstrong
2025-03-27 10:30:07 -07:00
parent 2cd58fbc9a
commit ceab6e8bcc
782 changed files with 107230 additions and 106548 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
Samples/5_Domain_Specific/volumeRender/README.md
View File

@@ -34,4 +34,3 @@ Download and install the [CUDA Toolkit 12.5](https://developer.nvidia.com/cuda-d
Make sure the dependencies mentioned in [Dependencies]() section above are installed.
## References (for more details)

781
Samples/5_Domain_Specific/volumeRender/volumeRender.cpp
View File

@@ -53,12 +53,12 @@
#endif
// CUDA Runtime, Interop, and includes
#include <cuda_runtime.h>
#include <cuda_gl_interop.h>
#include <cuda_profiler_api.h>
#include <vector_types.h>
#include <vector_functions.h>
#include <cuda_runtime.h>
#include <driver_functions.h>
#include <vector_functions.h>
#include <vector_types.h>
// CUDA utilities
#include <helper_cuda.h>
@@ -68,11 +68,11 @@
#include <helper_functions.h>
#include <helper_timer.h>
typedef unsigned int uint;
typedef unsigned int uint;
typedef unsigned char uchar;
#define MAX_EPSILON_ERROR 5.00f
#define THRESHOLD 0.30f
#define THRESHOLD 0.30f
// Define the files that are to be save and the reference images for validation
const char *sOriginal[] = {"volume.ppm", NULL};
@@ -81,8 +81,8 @@ const char *sReference[] = {"ref_volume.ppm", NULL};
const char *sSDKsample = "CUDA 3D Volume Render";
const char *volumeFilename = "Bucky.raw";
cudaExtent volumeSize = make_cudaExtent(32, 32, 32);
const char *volumeFilename = "Bucky.raw";
cudaExtent volumeSize = make_cudaExtent(32, 32, 32);
typedef unsigned char VolumeType;
// char *volumeFilename = "mrt16_angio.raw";
@@ -95,29 +95,28 @@ dim3 gridSize;
float3 viewRotation;
float3 viewTranslation = make_float3(0.0, 0.0, -4.0f);
float invViewMatrix[12];
float invViewMatrix[12];
float density = 0.05f;
float brightness = 1.0f;
float transferOffset = 0.0f;
float transferScale = 1.0f;
bool linearFiltering = true;
float density = 0.05f;
float brightness = 1.0f;
float transferOffset = 0.0f;
float transferScale = 1.0f;
bool linearFiltering = true;
GLuint pbo = 0; // OpenGL pixel buffer object
GLuint tex = 0; // OpenGL texture object
struct cudaGraphicsResource
*cuda_pbo_resource; // CUDA Graphics Resource (to transfer PBO)
GLuint pbo = 0; // OpenGL pixel buffer object
GLuint tex = 0; // OpenGL texture object
struct cudaGraphicsResource *cuda_pbo_resource; // CUDA Graphics Resource (to transfer PBO)
StopWatchInterface *timer = 0;
// Auto-Verification Code
const int frameCheckNumber = 2;
int fpsCount = 0; // FPS count for averaging
int fpsLimit = 1; // FPS limit for sampling
int g_Index = 0;
unsigned int frameCount = 0;
const int frameCheckNumber = 2;
int fpsCount = 0; // FPS count for averaging
int fpsLimit = 1; // FPS limit for sampling
int g_Index = 0;
unsigned int frameCount = 0;
int *pArgc;
int *pArgc;
char **pArgv;
#ifndef MAX
@@ -127,93 +126,99 @@ char **pArgv;
extern "C" void setTextureFilterMode(bool bLinearFilter);
extern "C" void initCuda(void *h_volume, cudaExtent volumeSize);
extern "C" void freeCudaBuffers();
extern "C" void render_kernel(dim3 gridSize, dim3 blockSize, uint *d_output,
uint imageW, uint imageH, float density,
float brightness, float transferOffset,
extern "C" void render_kernel(dim3 gridSize,
dim3 blockSize,
uint *d_output,
uint imageW,
uint imageH,
float density,
float brightness,
float transferOffset,
float transferScale);
extern "C" void copyInvViewMatrix(float *invViewMatrix, size_t sizeofMatrix);
void initPixelBuffer();
void computeFPS() {
frameCount++;
fpsCount++;
void computeFPS()
{
frameCount++;
fpsCount++;
if (fpsCount == fpsLimit) {
char fps[256];
float ifps = 1.f / (sdkGetAverageTimerValue(&timer) / 1000.f);
sprintf(fps, "Volume Render: %3.1f fps", ifps);
if (fpsCount == fpsLimit) {
char fps[256];
float ifps = 1.f / (sdkGetAverageTimerValue(&timer) / 1000.f);
sprintf(fps, "Volume Render: %3.1f fps", ifps);
glutSetWindowTitle(fps);
fpsCount = 0;
glutSetWindowTitle(fps);
fpsCount = 0;
fpsLimit = (int)MAX(1.f, ifps);
sdkResetTimer(&timer);
}
fpsLimit = (int)MAX(1.f, ifps);
sdkResetTimer(&timer);
}
}
// render image using CUDA
void render() {
copyInvViewMatrix(invViewMatrix, sizeof(float4) * 3);
void render()
{
copyInvViewMatrix(invViewMatrix, sizeof(float4) * 3);
// map PBO to get CUDA device pointer
uint *d_output;
// map PBO to get CUDA device pointer
checkCudaErrors(cudaGraphicsMapResources(1, &cuda_pbo_resource, 0));
size_t num_bytes;
checkCudaErrors(cudaGraphicsResourceGetMappedPointer(
(void **)&d_output, &num_bytes, cuda_pbo_resource));
// printf("CUDA mapped PBO: May access %ld bytes\n", num_bytes);
// map PBO to get CUDA device pointer
uint *d_output;
// map PBO to get CUDA device pointer
checkCudaErrors(cudaGraphicsMapResources(1, &cuda_pbo_resource, 0));
size_t num_bytes;
checkCudaErrors(cudaGraphicsResourceGetMappedPointer((void **)&d_output, &num_bytes, cuda_pbo_resource));
// printf("CUDA mapped PBO: May access %ld bytes\n", num_bytes);
// clear image
checkCudaErrors(cudaMemset(d_output, 0, width * height * 4));
// clear image
checkCudaErrors(cudaMemset(d_output, 0, width * height * 4));
// call CUDA kernel, writing results to PBO
render_kernel(gridSize, blockSize, d_output, width, height, density,
brightness, transferOffset, transferScale);
// call CUDA kernel, writing results to PBO
render_kernel(gridSize, blockSize, d_output, width, height, density, brightness, transferOffset, transferScale);
getLastCudaError("kernel failed");
getLastCudaError("kernel failed");
checkCudaErrors(cudaGraphicsUnmapResources(1, &cuda_pbo_resource, 0));
checkCudaErrors(cudaGraphicsUnmapResources(1, &cuda_pbo_resource, 0));
}
// display results using OpenGL (called by GLUT)
void display() {
sdkStartTimer(&timer);
void display()
{
sdkStartTimer(&timer);
// use OpenGL to build view matrix
GLfloat modelView[16];
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glRotatef(-viewRotation.x, 1.0, 0.0, 0.0);
glRotatef(-viewRotation.y, 0.0, 1.0, 0.0);
glTranslatef(-viewTranslation.x, -viewTranslation.y, -viewTranslation.z);
glGetFloatv(GL_MODELVIEW_MATRIX, modelView);
glPopMatrix();
// use OpenGL to build view matrix
GLfloat modelView[16];
glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();
glRotatef(-viewRotation.x, 1.0, 0.0, 0.0);
glRotatef(-viewRotation.y, 0.0, 1.0, 0.0);
glTranslatef(-viewTranslation.x, -viewTranslation.y, -viewTranslation.z);
glGetFloatv(GL_MODELVIEW_MATRIX, modelView);
glPopMatrix();
invViewMatrix[0] = modelView[0];
invViewMatrix[1] = modelView[4];
invViewMatrix[2] = modelView[8];
invViewMatrix[3] = modelView[12];
invViewMatrix[4] = modelView[1];
invViewMatrix[5] = modelView[5];
invViewMatrix[6] = modelView[9];
invViewMatrix[7] = modelView[13];
invViewMatrix[8] = modelView[2];
invViewMatrix[9] = modelView[6];
invViewMatrix[10] = modelView[10];
invViewMatrix[11] = modelView[14];
invViewMatrix[0] = modelView[0];
invViewMatrix[1] = modelView[4];
invViewMatrix[2] = modelView[8];
invViewMatrix[3] = modelView[12];
invViewMatrix[4] = modelView[1];
invViewMatrix[5] = modelView[5];
invViewMatrix[6] = modelView[9];
invViewMatrix[7] = modelView[13];
invViewMatrix[8] = modelView[2];
invViewMatrix[9] = modelView[6];
invViewMatrix[10] = modelView[10];
invViewMatrix[11] = modelView[14];
render();
render();
// display results
glClear(GL_COLOR_BUFFER_BIT);
// display results
glClear(GL_COLOR_BUFFER_BIT);
// draw image from PBO
glDisable(GL_DEPTH_TEST);
// draw image from PBO
glDisable(GL_DEPTH_TEST);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
#if 0
// draw using glDrawPixels (slower)
glRasterPos2i(0, 0);
@@ -221,417 +226,423 @@ void display() {
glDrawPixels(width, height, GL_RGBA, GL_UNSIGNED_BYTE, 0);
glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
#else
// draw using texture
// draw using texture
// copy from pbo to texture
glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, pbo);
glBindTexture(GL_TEXTURE_2D, tex);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, GL_RGBA,
GL_UNSIGNED_BYTE, 0);
glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
// copy from pbo to texture
glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, pbo);
glBindTexture(GL_TEXTURE_2D, tex);
glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, width, height, GL_RGBA, GL_UNSIGNED_BYTE, 0);
glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
// draw textured quad
glEnable(GL_TEXTURE_2D);
glBegin(GL_QUADS);
glTexCoord2f(0, 0);
glVertex2f(0, 0);
glTexCoord2f(1, 0);
glVertex2f(1, 0);
glTexCoord2f(1, 1);
glVertex2f(1, 1);
glTexCoord2f(0, 1);
glVertex2f(0, 1);
glEnd();
// draw textured quad
glEnable(GL_TEXTURE_2D);
glBegin(GL_QUADS);
glTexCoord2f(0, 0);
glVertex2f(0, 0);
glTexCoord2f(1, 0);
glVertex2f(1, 0);
glTexCoord2f(1, 1);
glVertex2f(1, 1);
glTexCoord2f(0, 1);
glVertex2f(0, 1);
glEnd();
glDisable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, 0);
glDisable(GL_TEXTURE_2D);
glBindTexture(GL_TEXTURE_2D, 0);
#endif
glutSwapBuffers();
glutReportErrors();
glutSwapBuffers();
glutReportErrors();
sdkStopTimer(&timer);
sdkStopTimer(&timer);
computeFPS();
computeFPS();
}
void idle() { glutPostRedisplay(); }
void keyboard(unsigned char key, int x, int y) {
switch (key) {
void keyboard(unsigned char key, int x, int y)
{
switch (key) {
case 27:
#if defined(__APPLE__) || defined(MACOSX)
exit(EXIT_SUCCESS);
exit(EXIT_SUCCESS);
#else
glutDestroyWindow(glutGetWindow());
return;
glutDestroyWindow(glutGetWindow());
return;
#endif
break;
break;
case 'f':
linearFiltering = !linearFiltering;
setTextureFilterMode(linearFiltering);
break;
linearFiltering = !linearFiltering;
setTextureFilterMode(linearFiltering);
break;
case '+':
density += 0.01f;
break;
density += 0.01f;
break;
case '-':
density -= 0.01f;
break;
density -= 0.01f;
break;
case ']':
brightness += 0.1f;
break;
brightness += 0.1f;
break;
case '[':
brightness -= 0.1f;
break;
brightness -= 0.1f;
break;
case ';':
transferOffset += 0.01f;
break;
transferOffset += 0.01f;
break;
case '\'':
transferOffset -= 0.01f;
break;
transferOffset -= 0.01f;
break;
case '.':
transferScale += 0.01f;
break;
transferScale += 0.01f;
break;
case ',':
transferScale -= 0.01f;
break;
transferScale -= 0.01f;
break;
default:
break;
}
break;
}
printf(
"density = %.2f, brightness = %.2f, transferOffset = %.2f, transferScale "
"= %.2f\n",
density, brightness, transferOffset, transferScale);
glutPostRedisplay();
printf("density = %.2f, brightness = %.2f, transferOffset = %.2f, transferScale "
"= %.2f\n",
density,
brightness,
transferOffset,
transferScale);
glutPostRedisplay();
}
int ox, oy;
int buttonState = 0;
void mouse(int button, int state, int x, int y) {
if (state == GLUT_DOWN) {
buttonState |= 1 << button;
} else if (state == GLUT_UP) {
buttonState = 0;
}
void mouse(int button, int state, int x, int y)
{
if (state == GLUT_DOWN) {
buttonState |= 1 << button;
}
else if (state == GLUT_UP) {
buttonState = 0;
}
ox = x;
oy = y;
glutPostRedisplay();
ox = x;
oy = y;
glutPostRedisplay();
}
void motion(int x, int y) {
float dx, dy;
dx = (float)(x - ox);
dy = (float)(y - oy);
void motion(int x, int y)
{
float dx, dy;
dx = (float)(x - ox);
dy = (float)(y - oy);
if (buttonState == 4) {
// right = zoom
viewTranslation.z += dy / 100.0f;
} else if (buttonState == 2) {
// middle = translate
viewTranslation.x += dx / 100.0f;
viewTranslation.y -= dy / 100.0f;
} else if (buttonState == 1) {
// left = rotate
viewRotation.x += dy / 5.0f;
viewRotation.y += dx / 5.0f;
}
if (buttonState == 4) {
// right = zoom
viewTranslation.z += dy / 100.0f;
}
else if (buttonState == 2) {
// middle = translate
viewTranslation.x += dx / 100.0f;
viewTranslation.y -= dy / 100.0f;
}
else if (buttonState == 1) {
// left = rotate
viewRotation.x += dy / 5.0f;
viewRotation.y += dx / 5.0f;
}
ox = x;
oy = y;
glutPostRedisplay();
ox = x;
oy = y;
glutPostRedisplay();
}
int iDivUp(int a, int b) { return (a % b != 0) ? (a / b + 1) : (a / b); }
void reshape(int w, int h) {
width = w;
height = h;
initPixelBuffer();
void reshape(int w, int h)
{
width = w;
height = h;
initPixelBuffer();
// calculate new grid size
gridSize = dim3(iDivUp(width, blockSize.x), iDivUp(height, blockSize.y));
// calculate new grid size
gridSize = dim3(iDivUp(width, blockSize.x), iDivUp(height, blockSize.y));
glViewport(0, 0, w, h);
glViewport(0, 0, w, h);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0.0, 1.0, 0.0, 1.0, 0.0, 1.0);
glMatrixMode(GL_PROJECTION);
glLoadIdentity();
glOrtho(0.0, 1.0, 0.0, 1.0, 0.0, 1.0);
}
void cleanup() {
sdkDeleteTimer(&timer);
void cleanup()
{
sdkDeleteTimer(&timer);
freeCudaBuffers();
freeCudaBuffers();
if (pbo) {
cudaGraphicsUnregisterResource(cuda_pbo_resource);
glDeleteBuffers(1, &pbo);
glDeleteTextures(1, &tex);
}
// Calling cudaProfilerStop causes all profile data to be
// flushed before the application exits
checkCudaErrors(cudaProfilerStop());
if (pbo) {
cudaGraphicsUnregisterResource(cuda_pbo_resource);
glDeleteBuffers(1, &pbo);
glDeleteTextures(1, &tex);
}
// Calling cudaProfilerStop causes all profile data to be
// flushed before the application exits
checkCudaErrors(cudaProfilerStop());
}
void initGL(int *argc, char **argv) {
// initialize GLUT callback functions
glutInit(argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
glutInitWindowSize(width, height);
glutCreateWindow("CUDA volume rendering");
void initGL(int *argc, char **argv)
{
// initialize GLUT callback functions
glutInit(argc, argv);
glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE);
glutInitWindowSize(width, height);
glutCreateWindow("CUDA volume rendering");
if (!isGLVersionSupported(2, 0) ||
!areGLExtensionsSupported("GL_ARB_pixel_buffer_object")) {
printf("Required OpenGL extensions are missing.");
exit(EXIT_SUCCESS);
}
if (!isGLVersionSupported(2, 0) || !areGLExtensionsSupported("GL_ARB_pixel_buffer_object")) {
printf("Required OpenGL extensions are missing.");
exit(EXIT_SUCCESS);
}
}
void initPixelBuffer() {
if (pbo) {
// unregister this buffer object from CUDA C
checkCudaErrors(cudaGraphicsUnregisterResource(cuda_pbo_resource));
void initPixelBuffer()
{
if (pbo) {
// unregister this buffer object from CUDA C
checkCudaErrors(cudaGraphicsUnregisterResource(cuda_pbo_resource));
// delete old buffer
glDeleteBuffers(1, &pbo);
glDeleteTextures(1, &tex);
}
// delete old buffer
glDeleteBuffers(1, &pbo);
glDeleteTextures(1, &tex);
}
// create pixel buffer object for display
glGenBuffers(1, &pbo);
glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, pbo);
glBufferData(GL_PIXEL_UNPACK_BUFFER_ARB, width * height * sizeof(GLubyte) * 4,
0, GL_STREAM_DRAW_ARB);
glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
// create pixel buffer object for display
glGenBuffers(1, &pbo);
glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, pbo);
glBufferData(GL_PIXEL_UNPACK_BUFFER_ARB, width * height * sizeof(GLubyte) * 4, 0, GL_STREAM_DRAW_ARB);
glBindBuffer(GL_PIXEL_UNPACK_BUFFER_ARB, 0);
// register this buffer object with CUDA
checkCudaErrors(cudaGraphicsGLRegisterBuffer(
&cuda_pbo_resource, pbo, cudaGraphicsMapFlagsWriteDiscard));
// register this buffer object with CUDA
checkCudaErrors(cudaGraphicsGLRegisterBuffer(&cuda_pbo_resource, pbo, cudaGraphicsMapFlagsWriteDiscard));
// create texture for display
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA,
GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glBindTexture(GL_TEXTURE_2D, 0);
// create texture for display
glGenTextures(1, &tex);
glBindTexture(GL_TEXTURE_2D, tex);
glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
glBindTexture(GL_TEXTURE_2D, 0);
}
// Load raw data from disk
void *loadRawFile(char *filename, size_t size) {
FILE *fp = fopen(filename, "rb");
void *loadRawFile(char *filename, size_t size)
{
FILE *fp = fopen(filename, "rb");
if (!fp) {
fprintf(stderr, "Error opening file '%s'\n", filename);
return 0;
}
void *data = malloc(size);
size_t read = fread(data, 1, size, fp);
fclose(fp);
#if defined(_MSC_VER_)
printf("Read '%s', %Iu bytes\n", filename, read);
#else
printf("Read '%s', %zu bytes\n", filename, read);
#endif
return data;
}
void runSingleTest(const char *ref_file, const char *exec_path) {
bool bTestResult = true;
uint *d_output;
checkCudaErrors(
cudaMalloc((void **)&d_output, width * height * sizeof(uint)));
checkCudaErrors(cudaMemset(d_output, 0, width * height * sizeof(uint)));
float modelView[16] = {1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 4.0f, 1.0f};
invViewMatrix[0] = modelView[0];
invViewMatrix[1] = modelView[4];
invViewMatrix[2] = modelView[8];
invViewMatrix[3] = modelView[12];
invViewMatrix[4] = modelView[1];
invViewMatrix[5] = modelView[5];
invViewMatrix[6] = modelView[9];
invViewMatrix[7] = modelView[13];
invViewMatrix[8] = modelView[2];
invViewMatrix[9] = modelView[6];
invViewMatrix[10] = modelView[10];
invViewMatrix[11] = modelView[14];
// call CUDA kernel, writing results to PBO
copyInvViewMatrix(invViewMatrix, sizeof(float4) * 3);
// Start timer 0 and process n loops on the GPU
int nIter = 10;
for (int i = -1; i < nIter; i++) {
if (i == 0) {
cudaDeviceSynchronize();
sdkStartTimer(&timer);
if (!fp) {
fprintf(stderr, "Error opening file '%s'\n", filename);
return 0;
}
render_kernel(gridSize, blockSize, d_output, width, height, density,
brightness, transferOffset, transferScale);
}
void *data = malloc(size);
size_t read = fread(data, 1, size, fp);
fclose(fp);
cudaDeviceSynchronize();
sdkStopTimer(&timer);
// Get elapsed time and throughput, then log to sample and master logs
double dAvgTime = sdkGetTimerValue(&timer) / (nIter * 1000.0);
printf(
"volumeRender, Throughput = %.4f MTexels/s, Time = %.5f s, Size = %u "
"Texels, NumDevsUsed = %u, Workgroup = %u\n",
(1.0e-6 * width * height) / dAvgTime, dAvgTime, (width * height), 1,
blockSize.x * blockSize.y);
#if defined(_MSC_VER_)
printf("Read '%s', %Iu bytes\n", filename, read);
#else
printf("Read '%s', %zu bytes\n", filename, read);
#endif
getLastCudaError("Error: render_kernel() execution FAILED");
checkCudaErrors(cudaDeviceSynchronize());
return data;
}
unsigned char *h_output = (unsigned char *)malloc(width * height * 4);
checkCudaErrors(cudaMemcpy(h_output, d_output, width * height * 4,
cudaMemcpyDeviceToHost));
void runSingleTest(const char *ref_file, const char *exec_path)
{
bool bTestResult = true;
sdkSavePPM4ub("volume.ppm", h_output, width, height);
bTestResult =
sdkComparePPM("volume.ppm", sdkFindFilePath(ref_file, exec_path),
MAX_EPSILON_ERROR, THRESHOLD, true);
uint *d_output;
checkCudaErrors(cudaMalloc((void **)&d_output, width * height * sizeof(uint)));
checkCudaErrors(cudaMemset(d_output, 0, width * height * sizeof(uint)));
cudaFree(d_output);
free(h_output);
cleanup();
float modelView[16] = {
1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 4.0f, 1.0f};
exit(bTestResult ? EXIT_SUCCESS : EXIT_FAILURE);
invViewMatrix[0] = modelView[0];
invViewMatrix[1] = modelView[4];
invViewMatrix[2] = modelView[8];
invViewMatrix[3] = modelView[12];
invViewMatrix[4] = modelView[1];
invViewMatrix[5] = modelView[5];
invViewMatrix[6] = modelView[9];
invViewMatrix[7] = modelView[13];
invViewMatrix[8] = modelView[2];
invViewMatrix[9] = modelView[6];
invViewMatrix[10] = modelView[10];
invViewMatrix[11] = modelView[14];
// call CUDA kernel, writing results to PBO
copyInvViewMatrix(invViewMatrix, sizeof(float4) * 3);
// Start timer 0 and process n loops on the GPU
int nIter = 10;
for (int i = -1; i < nIter; i++) {
if (i == 0) {
cudaDeviceSynchronize();
sdkStartTimer(&timer);
}
render_kernel(gridSize, blockSize, d_output, width, height, density, brightness, transferOffset, transferScale);
}
cudaDeviceSynchronize();
sdkStopTimer(&timer);
// Get elapsed time and throughput, then log to sample and master logs
double dAvgTime = sdkGetTimerValue(&timer) / (nIter * 1000.0);
printf("volumeRender, Throughput = %.4f MTexels/s, Time = %.5f s, Size = %u "
"Texels, NumDevsUsed = %u, Workgroup = %u\n",
(1.0e-6 * width * height) / dAvgTime,
dAvgTime,
(width * height),
1,
blockSize.x * blockSize.y);
getLastCudaError("Error: render_kernel() execution FAILED");
checkCudaErrors(cudaDeviceSynchronize());
unsigned char *h_output = (unsigned char *)malloc(width * height * 4);
checkCudaErrors(cudaMemcpy(h_output, d_output, width * height * 4, cudaMemcpyDeviceToHost));
sdkSavePPM4ub("volume.ppm", h_output, width, height);
bTestResult = sdkComparePPM("volume.ppm", sdkFindFilePath(ref_file, exec_path), MAX_EPSILON_ERROR, THRESHOLD, true);
cudaFree(d_output);
free(h_output);
cleanup();
exit(bTestResult ? EXIT_SUCCESS : EXIT_FAILURE);
}
////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int main(int argc, char **argv) {
pArgc = &argc;
pArgv = argv;
int main(int argc, char **argv)
{
pArgc = &argc;
pArgv = argv;
char *ref_file = NULL;
char *ref_file = NULL;
#if defined(__linux__)
setenv("DISPLAY", ":0", 0);
setenv("DISPLAY", ":0", 0);
#endif
// start logs
printf("%s Starting...\n\n", sSDKsample);
// start logs
printf("%s Starting...\n\n", sSDKsample);
if (checkCmdLineFlag(argc, (const char **)argv, "file")) {
getCmdLineArgumentString(argc, (const char **)argv, "file", &ref_file);
fpsLimit = frameCheckNumber;
}
if (checkCmdLineFlag(argc, (const char **)argv, "file")) {
getCmdLineArgumentString(argc, (const char **)argv, "file", &ref_file);
fpsLimit = frameCheckNumber;
}
if (ref_file) {
findCudaDevice(argc, (const char **)argv);
} else {
// First initialize OpenGL context, so we can properly set the GL for CUDA.
// This is necessary in order to achieve optimal performance with
// OpenGL/CUDA interop.
initGL(&argc, argv);
if (ref_file) {
findCudaDevice(argc, (const char **)argv);
}
else {
// First initialize OpenGL context, so we can properly set the GL for CUDA.
// This is necessary in order to achieve optimal performance with
// OpenGL/CUDA interop.
initGL(&argc, argv);
findCudaDevice(argc, (const char **)argv);
}
findCudaDevice(argc, (const char **)argv);
}
// parse arguments
char *filename;
// parse arguments
char *filename;
if (getCmdLineArgumentString(argc, (const char **)argv, "volume",
&filename)) {
volumeFilename = filename;
}
if (getCmdLineArgumentString(argc, (const char **)argv, "volume", &filename)) {
volumeFilename = filename;
}
int n;
int n;
if (checkCmdLineFlag(argc, (const char **)argv, "size")) {
n = getCmdLineArgumentInt(argc, (const char **)argv, "size");
volumeSize.width = volumeSize.height = volumeSize.depth = n;
}
if (checkCmdLineFlag(argc, (const char **)argv, "size")) {
n = getCmdLineArgumentInt(argc, (const char **)argv, "size");
volumeSize.width = volumeSize.height = volumeSize.depth = n;
}
if (checkCmdLineFlag(argc, (const char **)argv, "xsize")) {
n = getCmdLineArgumentInt(argc, (const char **)argv, "xsize");
volumeSize.width = n;
}
if (checkCmdLineFlag(argc, (const char **)argv, "xsize")) {
n = getCmdLineArgumentInt(argc, (const char **)argv, "xsize");
volumeSize.width = n;
}
if (checkCmdLineFlag(argc, (const char **)argv, "ysize")) {
n = getCmdLineArgumentInt(argc, (const char **)argv, "ysize");
volumeSize.height = n;
}
if (checkCmdLineFlag(argc, (const char **)argv, "ysize")) {
n = getCmdLineArgumentInt(argc, (const char **)argv, "ysize");
volumeSize.height = n;
}
if (checkCmdLineFlag(argc, (const char **)argv, "zsize")) {
n = getCmdLineArgumentInt(argc, (const char **)argv, "zsize");
volumeSize.depth = n;
}
if (checkCmdLineFlag(argc, (const char **)argv, "zsize")) {
n = getCmdLineArgumentInt(argc, (const char **)argv, "zsize");
volumeSize.depth = n;
}
// load volume data
char *path = sdkFindFilePath(volumeFilename, argv[0]);
// load volume data
char *path = sdkFindFilePath(volumeFilename, argv[0]);
if (path == 0) {
printf("Error finding file '%s'\n", volumeFilename);
exit(EXIT_FAILURE);
}
if (path == 0) {
printf("Error finding file '%s'\n", volumeFilename);
exit(EXIT_FAILURE);
}
size_t size = volumeSize.width * volumeSize.height * volumeSize.depth *
sizeof(VolumeType);
void *h_volume = loadRawFile(path, size);
size_t size = volumeSize.width * volumeSize.height * volumeSize.depth * sizeof(VolumeType);
void *h_volume = loadRawFile(path, size);
initCuda(h_volume, volumeSize);
free(h_volume);
initCuda(h_volume, volumeSize);
free(h_volume);
sdkCreateTimer(&timer);
sdkCreateTimer(&timer);
printf(
"Press '+' and '-' to change density (0.01 increments)\n"
" ']' and '[' to change brightness\n"
" ';' and ''' to modify transfer function offset\n"
" '.' and ',' to modify transfer function scale\n\n");
printf("Press '+' and '-' to change density (0.01 increments)\n"
" ']' and '[' to change brightness\n"
" ';' and ''' to modify transfer function offset\n"
" '.' and ',' to modify transfer function scale\n\n");
// calculate new grid size
gridSize = dim3(iDivUp(width, blockSize.x), iDivUp(height, blockSize.y));
// calculate new grid size
gridSize = dim3(iDivUp(width, blockSize.x), iDivUp(height, blockSize.y));
if (ref_file) {
runSingleTest(ref_file, argv[0]);
} else {
// This is the normal rendering path for VolumeRender
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutReshapeFunc(reshape);
glutIdleFunc(idle);
if (ref_file) {
runSingleTest(ref_file, argv[0]);
}
else {
// This is the normal rendering path for VolumeRender
glutDisplayFunc(display);
glutKeyboardFunc(keyboard);
glutMouseFunc(mouse);
glutMotionFunc(motion);
glutReshapeFunc(reshape);
glutIdleFunc(idle);
initPixelBuffer();
initPixelBuffer();
#if defined(__APPLE__) || defined(MACOSX)
atexit(cleanup);
atexit(cleanup);
#else
glutCloseFunc(cleanup);
glutCloseFunc(cleanup);
#endif
glutMainLoop();
}
glutMainLoop();
}
}

496
Samples/5_Domain_Specific/volumeRender/volumeRender_kernel.cu
View File

@@ -33,7 +33,7 @@
#include <helper_cuda.h>
#include <helper_math.h>
typedef unsigned int uint;
typedef unsigned int uint;
typedef unsigned char uchar;
cudaArray *d_volumeArray = 0;
@@ -42,270 +42,328 @@ cudaArray *d_transferFuncArray;
typedef unsigned char VolumeType;
// typedef unsigned short VolumeType;
cudaTextureObject_t texObject; // For 3D texture
cudaTextureObject_t transferTex; // For 1D transfer function texture
cudaTextureObject_t texObject; // For 3D texture
cudaTextureObject_t transferTex; // For 1D transfer function texture
typedef struct { float4 m[3]; } float3x4;
typedef struct
{
float4 m[3];
} float3x4;
__constant__ float3x4 c_invViewMatrix; // inverse view matrix
__constant__ float3x4 c_invViewMatrix; // inverse view matrix
struct Ray {
float3 o; // origin
float3 d; // direction
struct Ray
{
float3 o; // origin
float3 d; // direction
};
// intersect ray with a box
// http://www.siggraph.org/education/materials/HyperGraph/raytrace/rtinter3.htm
__device__ int intersectBox(Ray r, float3 boxmin, float3 boxmax, float *tnear,
float *tfar) {
// compute intersection of ray with all six bbox planes
float3 invR = make_float3(1.0f) / r.d;
float3 tbot = invR * (boxmin - r.o);
float3 ttop = invR * (boxmax - r.o);
__device__ int intersectBox(Ray r, float3 boxmin, float3 boxmax, float *tnear, float *tfar)
{
// compute intersection of ray with all six bbox planes
float3 invR = make_float3(1.0f) / r.d;
float3 tbot = invR * (boxmin - r.o);
float3 ttop = invR * (boxmax - r.o);
// re-order intersections to find smallest and largest on each axis
float3 tmin = fminf(ttop, tbot);
float3 tmax = fmaxf(ttop, tbot);
// re-order intersections to find smallest and largest on each axis
float3 tmin = fminf(ttop, tbot);
float3 tmax = fmaxf(ttop, tbot);
// find the largest tmin and the smallest tmax
float largest_tmin = fmaxf(fmaxf(tmin.x, tmin.y), fmaxf(tmin.x, tmin.z));
float smallest_tmax = fminf(fminf(tmax.x, tmax.y), fminf(tmax.x, tmax.z));
// find the largest tmin and the smallest tmax
float largest_tmin = fmaxf(fmaxf(tmin.x, tmin.y), fmaxf(tmin.x, tmin.z));
float smallest_tmax = fminf(fminf(tmax.x, tmax.y), fminf(tmax.x, tmax.z));
*tnear = largest_tmin;
*tfar = smallest_tmax;
*tnear = largest_tmin;
*tfar = smallest_tmax;
return smallest_tmax > largest_tmin;
return smallest_tmax > largest_tmin;
}
// transform vector by matrix (no translation)
__device__ float3 mul(const float3x4 &M, const float3 &v) {
float3 r;
r.x = dot(v, make_float3(M.m[0]));
r.y = dot(v, make_float3(M.m[1]));
r.z = dot(v, make_float3(M.m[2]));
return r;
__device__ float3 mul(const float3x4 &M, const float3 &v)
{
float3 r;
r.x = dot(v, make_float3(M.m[0]));
r.y = dot(v, make_float3(M.m[1]));
r.z = dot(v, make_float3(M.m[2]));
return r;
}
// transform vector by matrix with translation
__device__ float4 mul(const float3x4 &M, const float4 &v) {
float4 r;
r.x = dot(v, M.m[0]);
r.y = dot(v, M.m[1]);
r.z = dot(v, M.m[2]);
r.w = 1.0f;
return r;
__device__ float4 mul(const float3x4 &M, const float4 &v)
{
float4 r;
r.x = dot(v, M.m[0]);
r.y = dot(v, M.m[1]);
r.z = dot(v, M.m[2]);
r.w = 1.0f;
return r;
}
__device__ uint rgbaFloatToInt(float4 rgba) {
rgba.x = __saturatef(rgba.x); // clamp to [0.0, 1.0]
rgba.y = __saturatef(rgba.y);
rgba.z = __saturatef(rgba.z);
rgba.w = __saturatef(rgba.w);
return (uint(rgba.w * 255) << 24) | (uint(rgba.z * 255) << 16) |
(uint(rgba.y * 255) << 8) | uint(rgba.x * 255);
__device__ uint rgbaFloatToInt(float4 rgba)
{
rgba.x = __saturatef(rgba.x); // clamp to [0.0, 1.0]
rgba.y = __saturatef(rgba.y);
rgba.z = __saturatef(rgba.z);
rgba.w = __saturatef(rgba.w);
return (uint(rgba.w * 255) << 24) | (uint(rgba.z * 255) << 16) | (uint(rgba.y * 255) << 8) | uint(rgba.x * 255);
}
__global__ void d_render(uint *d_output, uint imageW, uint imageH,
float density, float brightness, float transferOffset,
float transferScale, cudaTextureObject_t tex,
cudaTextureObject_t transferTex) {
const int maxSteps = 500;
const float tstep = 0.01f;
const float opacityThreshold = 0.95f;
const float3 boxMin = make_float3(-1.0f, -1.0f, -1.0f);
const float3 boxMax = make_float3(1.0f, 1.0f, 1.0f);
__global__ void d_render(uint *d_output,
uint imageW,
uint imageH,
float density,
float brightness,
float transferOffset,
float transferScale,
cudaTextureObject_t tex,
cudaTextureObject_t transferTex)
{
const int maxSteps = 500;
const float tstep = 0.01f;
const float opacityThreshold = 0.95f;
const float3 boxMin = make_float3(-1.0f, -1.0f, -1.0f);
const float3 boxMax = make_float3(1.0f, 1.0f, 1.0f);
uint x = blockIdx.x * blockDim.x + threadIdx.x;
uint y = blockIdx.y * blockDim.y + threadIdx.y;
uint x = blockIdx.x * blockDim.x + threadIdx.x;
uint y = blockIdx.y * blockDim.y + threadIdx.y;
if ((x >= imageW) || (y >= imageH)) return;
if ((x >= imageW) || (y >= imageH))
return;
float u = (x / (float)imageW) * 2.0f - 1.0f;
float v = (y / (float)imageH) * 2.0f - 1.0f;
float u = (x / (float)imageW) * 2.0f - 1.0f;
float v = (y / (float)imageH) * 2.0f - 1.0f;
// calculate eye ray in world space
Ray eyeRay;
eyeRay.o =
make_float3(mul(c_invViewMatrix, make_float4(0.0f, 0.0f, 0.0f, 1.0f)));
eyeRay.d = normalize(make_float3(u, v, -2.0f));
eyeRay.d = mul(c_invViewMatrix, eyeRay.d);
// calculate eye ray in world space
Ray eyeRay;
eyeRay.o = make_float3(mul(c_invViewMatrix, make_float4(0.0f, 0.0f, 0.0f, 1.0f)));
eyeRay.d = normalize(make_float3(u, v, -2.0f));
eyeRay.d = mul(c_invViewMatrix, eyeRay.d);
// find intersection with box
float tnear, tfar;
int hit = intersectBox(eyeRay, boxMin, boxMax, &tnear, &tfar);
// find intersection with box
float tnear, tfar;
int hit = intersectBox(eyeRay, boxMin, boxMax, &tnear, &tfar);
if (!hit) return;
if (!hit)
return;
if (tnear < 0.0f) tnear = 0.0f; // clamp to near plane
if (tnear < 0.0f)
tnear = 0.0f; // clamp to near plane
// march along ray from front to back, accumulating color
float4 sum = make_float4(0.0f);
float t = tnear;
float3 pos = eyeRay.o + eyeRay.d * tnear;
float3 step = eyeRay.d * tstep;
// march along ray from front to back, accumulating color
float4 sum = make_float4(0.0f);
float t = tnear;
float3 pos = eyeRay.o + eyeRay.d * tnear;
float3 step = eyeRay.d * tstep;
for (int i = 0; i < maxSteps; i++) {
// read from 3D texture
// remap position to [0, 1] coordinates
float sample = tex3D<float>(tex, pos.x * 0.5f + 0.5f, pos.y * 0.5f + 0.5f,
pos.z * 0.5f + 0.5f);
// sample *= 64.0f; // scale for 10-bit data
for (int i = 0; i < maxSteps; i++) {
// read from 3D texture
// remap position to [0, 1] coordinates
float sample = tex3D<float>(tex, pos.x * 0.5f + 0.5f, pos.y * 0.5f + 0.5f, pos.z * 0.5f + 0.5f);
// sample *= 64.0f; // scale for 10-bit data
// lookup in transfer function texture
float4 col =
tex1D<float4>(transferTex, (sample - transferOffset) * transferScale);
col.w *= density;
// lookup in transfer function texture
float4 col = tex1D<float4>(transferTex, (sample - transferOffset) * transferScale);
col.w *= density;
// "under" operator for back-to-front blending
// sum = lerp(sum, col, col.w);
// "under" operator for back-to-front blending
// sum = lerp(sum, col, col.w);
// pre-multiply alpha
col.x *= col.w;
col.y *= col.w;
col.z *= col.w;
// "over" operator for front-to-back blending
sum = sum + col * (1.0f - sum.w);
// pre-multiply alpha
col.x *= col.w;
col.y *= col.w;
col.z *= col.w;
// "over" operator for front-to-back blending
sum = sum + col * (1.0f - sum.w);
// exit early if opaque
if (sum.w > opacityThreshold) break;
// exit early if opaque
if (sum.w > opacityThreshold)
break;
t += tstep;
t += tstep;
if (t > tfar) break;
if (t > tfar)
break;
pos += step;
}
pos += step;
}
sum *= brightness;
sum *= brightness;
// write output color
d_output[y * imageW + x] = rgbaFloatToInt(sum);
// write output color
d_output[y * imageW + x] = rgbaFloatToInt(sum);
}
extern "C" void setTextureFilterMode(bool bLinearFilter) {
if (texObject) {
extern "C" void setTextureFilterMode(bool bLinearFilter)
{
if (texObject) {
checkCudaErrors(cudaDestroyTextureObject(texObject));
}
cudaResourceDesc texRes;
memset(&texRes, 0, sizeof(cudaResourceDesc));
texRes.resType = cudaResourceTypeArray;
texRes.res.array.array = d_volumeArray;
cudaTextureDesc texDescr;
memset(&texDescr, 0, sizeof(cudaTextureDesc));
texDescr.normalizedCoords = true;
texDescr.filterMode = bLinearFilter ? cudaFilterModeLinear : cudaFilterModePoint;
texDescr.addressMode[0] = cudaAddressModeWrap;
texDescr.addressMode[1] = cudaAddressModeWrap;
texDescr.addressMode[2] = cudaAddressModeWrap;
texDescr.readMode = cudaReadModeNormalizedFloat;
checkCudaErrors(cudaCreateTextureObject(&texObject, &texRes, &texDescr, NULL));
}
extern "C" void initCuda(void *h_volume, cudaExtent volumeSize)
{
// create 3D array
cudaChannelFormatDesc channelDesc = cudaCreateChannelDesc<VolumeType>();
checkCudaErrors(cudaMalloc3DArray(&d_volumeArray, &channelDesc, volumeSize));
// copy data to 3D array
cudaMemcpy3DParms copyParams = {0};
copyParams.srcPtr =
make_cudaPitchedPtr(h_volume, volumeSize.width * sizeof(VolumeType), volumeSize.width, volumeSize.height);
copyParams.dstArray = d_volumeArray;
copyParams.extent = volumeSize;
copyParams.kind = cudaMemcpyHostToDevice;
checkCudaErrors(cudaMemcpy3D(&copyParams));
cudaResourceDesc texRes;
memset(&texRes, 0, sizeof(cudaResourceDesc));
texRes.resType = cudaResourceTypeArray;
texRes.res.array.array = d_volumeArray;
cudaTextureDesc texDescr;
memset(&texDescr, 0, sizeof(cudaTextureDesc));
texDescr.normalizedCoords = true; // access with normalized texture coordinates
texDescr.filterMode = cudaFilterModeLinear; // linear interpolation
texDescr.addressMode[0] = cudaAddressModeClamp; // clamp texture coordinates
texDescr.addressMode[1] = cudaAddressModeClamp;
texDescr.addressMode[2] = cudaAddressModeClamp;
texDescr.readMode = cudaReadModeNormalizedFloat;
checkCudaErrors(cudaCreateTextureObject(&texObject, &texRes, &texDescr, NULL));
// create transfer function texture
float4 transferFunc[] = {
{
0.0,
0.0,
0.0,
0.0,
},
{
1.0,
0.0,
0.0,
1.0,
},
{
1.0,
0.5,
0.0,
1.0,
},
{
1.0,
1.0,
0.0,
1.0,
},
{
0.0,
1.0,
0.0,
1.0,
},
{
0.0,
1.0,
1.0,
1.0,
},
{
0.0,
0.0,
1.0,
1.0,
},
{
1.0,
0.0,
1.0,
1.0,
},
{
0.0,
0.0,
0.0,
0.0,
},
};
cudaChannelFormatDesc channelDesc2 = cudaCreateChannelDesc<float4>();
cudaArray *d_transferFuncArray;
checkCudaErrors(cudaMallocArray(&d_transferFuncArray, &channelDesc2, sizeof(transferFunc) / sizeof(float4), 1));
checkCudaErrors(cudaMemcpy2DToArray(
d_transferFuncArray, 0, 0, transferFunc, 0, sizeof(transferFunc), 1, cudaMemcpyHostToDevice));
memset(&texRes, 0, sizeof(cudaResourceDesc));
texRes.resType = cudaResourceTypeArray;
texRes.res.array.array = d_transferFuncArray;
memset(&texDescr, 0, sizeof(cudaTextureDesc));
texDescr.normalizedCoords = true; // access with normalized texture coordinates
texDescr.filterMode = cudaFilterModeLinear;
texDescr.addressMode[0] = cudaAddressModeClamp; // wrap texture coordinates
texDescr.readMode = cudaReadModeElementType;
checkCudaErrors(cudaCreateTextureObject(&transferTex, &texRes, &texDescr, NULL));
}
extern "C" void freeCudaBuffers()
{
checkCudaErrors(cudaDestroyTextureObject(texObject));
}
cudaResourceDesc texRes;
memset(&texRes, 0, sizeof(cudaResourceDesc));
texRes.resType = cudaResourceTypeArray;
texRes.res.array.array = d_volumeArray;
cudaTextureDesc texDescr;
memset(&texDescr, 0, sizeof(cudaTextureDesc));
texDescr.normalizedCoords = true;
texDescr.filterMode =
bLinearFilter ? cudaFilterModeLinear : cudaFilterModePoint;
texDescr.addressMode[0] = cudaAddressModeWrap;
texDescr.addressMode[1] = cudaAddressModeWrap;
texDescr.addressMode[2] = cudaAddressModeWrap;
texDescr.readMode = cudaReadModeNormalizedFloat;
checkCudaErrors(
cudaCreateTextureObject(&texObject, &texRes, &texDescr, NULL));
checkCudaErrors(cudaDestroyTextureObject(transferTex));
checkCudaErrors(cudaFreeArray(d_volumeArray));
checkCudaErrors(cudaFreeArray(d_transferFuncArray));
}
extern "C" void initCuda(void *h_volume, cudaExtent volumeSize) {
// create 3D array
cudaChannelFormatDesc channelDesc = cudaCreateChannelDesc<VolumeType>();
checkCudaErrors(cudaMalloc3DArray(&d_volumeArray, &channelDesc, volumeSize));
// copy data to 3D array
cudaMemcpy3DParms copyParams = {0};
copyParams.srcPtr =
make_cudaPitchedPtr(h_volume, volumeSize.width * sizeof(VolumeType),
volumeSize.width, volumeSize.height);
copyParams.dstArray = d_volumeArray;
copyParams.extent = volumeSize;
copyParams.kind = cudaMemcpyHostToDevice;
checkCudaErrors(cudaMemcpy3D(&copyParams));
cudaResourceDesc texRes;
memset(&texRes, 0, sizeof(cudaResourceDesc));
texRes.resType = cudaResourceTypeArray;
texRes.res.array.array = d_volumeArray;
cudaTextureDesc texDescr;
memset(&texDescr, 0, sizeof(cudaTextureDesc));
texDescr.normalizedCoords =
true; // access with normalized texture coordinates
texDescr.filterMode = cudaFilterModeLinear; // linear interpolation
texDescr.addressMode[0] = cudaAddressModeClamp; // clamp texture coordinates
texDescr.addressMode[1] = cudaAddressModeClamp;
texDescr.addressMode[2] = cudaAddressModeClamp;
texDescr.readMode = cudaReadModeNormalizedFloat;
checkCudaErrors(
cudaCreateTextureObject(&texObject, &texRes, &texDescr, NULL));
// create transfer function texture
float4 transferFunc[] = {
{ 0.0, 0.0, 0.0, 0.0, },
{ 1.0, 0.0, 0.0, 1.0, },
{ 1.0, 0.5, 0.0, 1.0, },
{ 1.0, 1.0, 0.0, 1.0, },
{ 0.0, 1.0, 0.0, 1.0, },
{ 0.0, 1.0, 1.0, 1.0, },
{ 0.0, 0.0, 1.0, 1.0, },
{ 1.0, 0.0, 1.0, 1.0, },
{ 0.0, 0.0, 0.0, 0.0, },
};
cudaChannelFormatDesc channelDesc2 = cudaCreateChannelDesc<float4>();
cudaArray *d_transferFuncArray;
checkCudaErrors(cudaMallocArray(&d_transferFuncArray, &channelDesc2,
sizeof(transferFunc) / sizeof(float4), 1));
checkCudaErrors(cudaMemcpy2DToArray(d_transferFuncArray, 0, 0, transferFunc,
0, sizeof(transferFunc), 1,
cudaMemcpyHostToDevice));
memset(&texRes, 0, sizeof(cudaResourceDesc));
texRes.resType = cudaResourceTypeArray;
texRes.res.array.array = d_transferFuncArray;
memset(&texDescr, 0, sizeof(cudaTextureDesc));
texDescr.normalizedCoords =
true; // access with normalized texture coordinates
texDescr.filterMode = cudaFilterModeLinear;
texDescr.addressMode[0] = cudaAddressModeClamp; // wrap texture coordinates
texDescr.readMode = cudaReadModeElementType;
checkCudaErrors(
cudaCreateTextureObject(&transferTex, &texRes, &texDescr, NULL));
extern "C" void render_kernel(dim3 gridSize,
dim3 blockSize,
uint *d_output,
uint imageW,
uint imageH,
float density,
float brightness,
float transferOffset,
float transferScale)
{
d_render<<<gridSize, blockSize>>>(
d_output, imageW, imageH, density, brightness, transferOffset, transferScale, texObject, transferTex);
}
extern "C" void freeCudaBuffers() {
checkCudaErrors(cudaDestroyTextureObject(texObject));
checkCudaErrors(cudaDestroyTextureObject(transferTex));
checkCudaErrors(cudaFreeArray(d_volumeArray));
checkCudaErrors(cudaFreeArray(d_transferFuncArray));
extern "C" void copyInvViewMatrix(float *invViewMatrix, size_t sizeofMatrix)
{
checkCudaErrors(cudaMemcpyToSymbol(c_invViewMatrix, invViewMatrix, sizeofMatrix));
}
extern "C" void render_kernel(dim3 gridSize, dim3 blockSize, uint *d_output,
uint imageW, uint imageH, float density,
float brightness, float transferOffset,
float transferScale) {
d_render<<<gridSize, blockSize>>>(d_output, imageW, imageH, density,
brightness, transferOffset, transferScale,
texObject, transferTex);
}
extern "C" void copyInvViewMatrix(float *invViewMatrix, size_t sizeofMatrix) {
checkCudaErrors(
cudaMemcpyToSymbol(c_invViewMatrix, invViewMatrix, sizeofMatrix));
}
#endif // #ifndef _VOLUMERENDER_KERNEL_CU_
#endif // #ifndef _VOLUMERENDER_KERNEL_CU_