mirror of
https://github.com/NVIDIA/cuda-samples.git
synced 2026-10-25 22:28:17 +08:00
Apply consistent code formatting across the repo. Add clang-format and pre-commit hooks.
This commit is contained in:
Rob Armstrong
@@ -39,4 +39,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)
|
||||
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -42,19 +42,19 @@
|
||||
|
||||
// includes, system
|
||||
#include <math.h>
|
||||
#include <stdarg.h>
|
||||
#include <stdio.h>
|
||||
#include <stdlib.h>
|
||||
#include <string.h>
|
||||
|
||||
#include <stdarg.h>
|
||||
#include <unistd.h>
|
||||
|
||||
void error_exit(const char *format, ...) {
|
||||
va_list args;
|
||||
va_start(args, format);
|
||||
vfprintf(stderr, format, args);
|
||||
va_end(args);
|
||||
exit(1);
|
||||
void error_exit(const char *format, ...)
|
||||
{
|
||||
va_list args;
|
||||
va_start(args, format);
|
||||
vfprintf(stderr, format, args);
|
||||
va_end(args);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
#if 0
|
||||
@@ -74,60 +74,60 @@ void error_exit(const char *format, ...) {
|
||||
#include <cuda_runtime.h>
|
||||
|
||||
// Utilities and timing functions
|
||||
#include <helper_functions.h> // includes cuda.h and cuda_runtime_api.h
|
||||
#include <helper_functions.h> // includes cuda.h and cuda_runtime_api.h
|
||||
|
||||
// CUDA helper functions
|
||||
#include <helper_cuda.h> // helper functions for CUDA error check
|
||||
//#include <helper_cuda_gl.h> // helper functions for CUDA/GL interop
|
||||
#include <helper_cuda.h> // helper functions for CUDA error check
|
||||
// #include <helper_cuda_gl.h> // helper functions for CUDA/GL interop
|
||||
|
||||
#include <vector_types.h>
|
||||
|
||||
#define MAX_EPSILON_ERROR 0.0f
|
||||
#define THRESHOLD 0.0f
|
||||
#define REFRESH_DELAY 1 // ms
|
||||
#define THRESHOLD 0.0f
|
||||
#define REFRESH_DELAY 1 // ms
|
||||
|
||||
#define GUI_IDLE 0x100
|
||||
#define GUI_ROTATE 0x101
|
||||
#define GUI_IDLE 0x100
|
||||
#define GUI_ROTATE 0x101
|
||||
#define GUI_TRANSLATE 0x102
|
||||
|
||||
int gui_mode;
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// constants
|
||||
const unsigned int window_width = 512;
|
||||
const unsigned int window_width = 512;
|
||||
const unsigned int window_height = 512;
|
||||
|
||||
const unsigned int mesh_width = 256;
|
||||
const unsigned int mesh_width = 256;
|
||||
const unsigned int mesh_height = 256;
|
||||
|
||||
// OpenGL ES variables and interop with CUDA C
|
||||
GLuint mesh_vao, mesh_vbo;
|
||||
GLuint mesh_vao, mesh_vbo;
|
||||
struct cudaGraphicsResource *cuda_vbo_resource;
|
||||
void *d_vbo_buffer = NULL;
|
||||
void *d_vbo_buffer = NULL;
|
||||
|
||||
float g_fAnim = 0.0;
|
||||
|
||||
// UI / mouse controls
|
||||
int mouse_old_x, mouse_old_y;
|
||||
int mouse_buttons = 0;
|
||||
int mouse_old_x, mouse_old_y;
|
||||
int mouse_buttons = 0;
|
||||
float rotate_x = 0.0, rotate_y = 0.0;
|
||||
float translate_z = -3.0;
|
||||
|
||||
StopWatchInterface *timer = NULL;
|
||||
|
||||
// Frame statistics
|
||||
int frame;
|
||||
int fpsCount = 0; // FPS count for averaging
|
||||
int fpsLimit = 1; // FPS limit for sampling
|
||||
int g_Index = 0;
|
||||
float avgFPS = 0.0f;
|
||||
unsigned int frameCount = 0;
|
||||
int frame;
|
||||
int fpsCount = 0; // FPS count for averaging
|
||||
int fpsLimit = 1; // FPS limit for sampling
|
||||
int g_Index = 0;
|
||||
float avgFPS = 0.0f;
|
||||
unsigned int frameCount = 0;
|
||||
unsigned int g_TotalErrors = 0;
|
||||
|
||||
// Auto-Verification Code
|
||||
bool g_bQAReadback = false;
|
||||
|
||||
int *pArgc = NULL;
|
||||
int *pArgc = NULL;
|
||||
char **pArgv = NULL;
|
||||
|
||||
#define MAX(a, b) ((a > b) ? a : b)
|
||||
@@ -142,76 +142,76 @@ void checkResultCuda(int argc, char **argv, const GLuint &vbo);
|
||||
|
||||
const char *sSDKsample = "simpleGLES (VBO)";
|
||||
|
||||
void computeFPS() {
|
||||
frameCount++;
|
||||
fpsCount++;
|
||||
void computeFPS()
|
||||
{
|
||||
frameCount++;
|
||||
fpsCount++;
|
||||
|
||||
if (fpsCount == fpsLimit) {
|
||||
avgFPS = 1.f / (sdkGetAverageTimerValue(&timer) / 1000.f);
|
||||
fpsCount = 0;
|
||||
fpsLimit = (int)MAX(avgFPS, 1.f);
|
||||
if (fpsCount == fpsLimit) {
|
||||
avgFPS = 1.f / (sdkGetAverageTimerValue(&timer) / 1000.f);
|
||||
fpsCount = 0;
|
||||
fpsLimit = (int)MAX(avgFPS, 1.f);
|
||||
|
||||
sdkResetTimer(&timer);
|
||||
}
|
||||
sdkResetTimer(&timer);
|
||||
}
|
||||
|
||||
char fps[256];
|
||||
sprintf(fps, "Cuda/OpenGL ES Interop (VBO): %3.1f fps (Max 1000 fps)",
|
||||
avgFPS);
|
||||
graphics_set_windowtitle(fps);
|
||||
char fps[256];
|
||||
sprintf(fps, "Cuda/OpenGL ES Interop (VBO): %3.1f fps (Max 1000 fps)", avgFPS);
|
||||
graphics_set_windowtitle(fps);
|
||||
}
|
||||
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
//! Simple kernel to modify vertex positions in sine wave pattern
|
||||
//! @param data data in global memory
|
||||
///////////////////////////////////////////////////////////////////////////////
|
||||
__global__ void simple_vbo_kernel(float4 *pos, unsigned int width,
|
||||
unsigned int height, float time) {
|
||||
unsigned int x = blockIdx.x * blockDim.x + threadIdx.x;
|
||||
unsigned int y = blockIdx.y * blockDim.y + threadIdx.y;
|
||||
__global__ void simple_vbo_kernel(float4 *pos, unsigned int width, unsigned int height, float time)
|
||||
{
|
||||
unsigned int x = blockIdx.x * blockDim.x + threadIdx.x;
|
||||
unsigned int y = blockIdx.y * blockDim.y + threadIdx.y;
|
||||
|
||||
// calculate uv coordinates
|
||||
float u = x / (float)width;
|
||||
float v = y / (float)height;
|
||||
u = u * 2.0f - 1.0f;
|
||||
v = v * 2.0f - 1.0f;
|
||||
// calculate uv coordinates
|
||||
float u = x / (float)width;
|
||||
float v = y / (float)height;
|
||||
u = u * 2.0f - 1.0f;
|
||||
v = v * 2.0f - 1.0f;
|
||||
|
||||
// calculate simple sine wave pattern
|
||||
float freq = 4.0f;
|
||||
float w = sinf(u * freq + time) * cosf(v * freq + time) * 0.5f;
|
||||
// calculate simple sine wave pattern
|
||||
float freq = 4.0f;
|
||||
float w = sinf(u * freq + time) * cosf(v * freq + time) * 0.5f;
|
||||
|
||||
// write output vertex
|
||||
pos[y * width + x] = make_float4(u, w, v, 1.0f);
|
||||
// write output vertex
|
||||
pos[y * width + x] = make_float4(u, w, v, 1.0f);
|
||||
}
|
||||
|
||||
void launch_kernel(float4 *pos, unsigned int mesh_width,
|
||||
unsigned int mesh_height, float time) {
|
||||
// execute the kernel
|
||||
dim3 block(8, 8, 1);
|
||||
dim3 grid(mesh_width / block.x, mesh_height / block.y, 1);
|
||||
simple_vbo_kernel<<<grid, block>>>(pos, mesh_width, mesh_height, time);
|
||||
void launch_kernel(float4 *pos, unsigned int mesh_width, unsigned int mesh_height, float time)
|
||||
{
|
||||
// execute the kernel
|
||||
dim3 block(8, 8, 1);
|
||||
dim3 grid(mesh_width / block.x, mesh_height / block.y, 1);
|
||||
simple_vbo_kernel<<<grid, block>>>(pos, mesh_width, mesh_height, time);
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
//! Run the Cuda part of the computation
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
void runCuda(struct cudaGraphicsResource **vbo_resource) {
|
||||
// map OpenGL buffer object for writing from CUDA
|
||||
float4 *dptr;
|
||||
cudaGraphicsMapResources(1, vbo_resource, 0);
|
||||
size_t num_bytes;
|
||||
cudaGraphicsResourceGetMappedPointer((void **)&dptr, &num_bytes,
|
||||
*vbo_resource);
|
||||
// printf("Sample CUDA mapped VBO: May access %ld bytes\n", num_bytes);
|
||||
void runCuda(struct cudaGraphicsResource **vbo_resource)
|
||||
{
|
||||
// map OpenGL buffer object for writing from CUDA
|
||||
float4 *dptr;
|
||||
cudaGraphicsMapResources(1, vbo_resource, 0);
|
||||
size_t num_bytes;
|
||||
cudaGraphicsResourceGetMappedPointer((void **)&dptr, &num_bytes, *vbo_resource);
|
||||
// printf("Sample CUDA mapped VBO: May access %ld bytes\n", num_bytes);
|
||||
|
||||
// execute the kernel
|
||||
// dim3 block(8, 8, 1);
|
||||
// dim3 grid(mesh_width / block.x, mesh_height / block.y, 1);
|
||||
// kernel<<< grid, block>>>(dptr, mesh_width, mesh_height, g_fAnim);
|
||||
// execute the kernel
|
||||
// dim3 block(8, 8, 1);
|
||||
// dim3 grid(mesh_width / block.x, mesh_height / block.y, 1);
|
||||
// kernel<<< grid, block>>>(dptr, mesh_width, mesh_height, g_fAnim);
|
||||
|
||||
launch_kernel(dptr, mesh_width, mesh_height, g_fAnim);
|
||||
launch_kernel(dptr, mesh_width, mesh_height, g_fAnim);
|
||||
|
||||
// unmap buffer object
|
||||
cudaGraphicsUnmapResources(1, vbo_resource, 0);
|
||||
// unmap buffer object
|
||||
cudaGraphicsUnmapResources(1, vbo_resource, 0);
|
||||
}
|
||||
|
||||
#ifdef _WIN32
|
||||
@@ -224,348 +224,348 @@ void runCuda(struct cudaGraphicsResource **vbo_resource) {
|
||||
#endif
|
||||
#endif
|
||||
|
||||
void sdkDumpBin2(void *data, unsigned int bytes, const char *filename) {
|
||||
printf("sdkDumpBin: <%s>\n", filename);
|
||||
FILE *fp;
|
||||
FOPEN(fp, filename, "wb");
|
||||
fwrite(data, bytes, 1, fp);
|
||||
fflush(fp);
|
||||
fclose(fp);
|
||||
void sdkDumpBin2(void *data, unsigned int bytes, const char *filename)
|
||||
{
|
||||
printf("sdkDumpBin: <%s>\n", filename);
|
||||
FILE *fp;
|
||||
FOPEN(fp, filename, "wb");
|
||||
fwrite(data, bytes, 1, fp);
|
||||
fflush(fp);
|
||||
fclose(fp);
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
//! Run the Cuda part of the computation
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
void runAutoTest(int devID, char **argv, char *ref_file) {
|
||||
char *reference_file = NULL;
|
||||
void *imageData = malloc(mesh_width * mesh_height * sizeof(float));
|
||||
void runAutoTest(int devID, char **argv, char *ref_file)
|
||||
{
|
||||
char *reference_file = NULL;
|
||||
void *imageData = malloc(mesh_width * mesh_height * sizeof(float));
|
||||
|
||||
// execute the kernel
|
||||
launch_kernel((float4 *)d_vbo_buffer, mesh_width, mesh_height, g_fAnim);
|
||||
// execute the kernel
|
||||
launch_kernel((float4 *)d_vbo_buffer, mesh_width, mesh_height, g_fAnim);
|
||||
|
||||
cudaDeviceSynchronize();
|
||||
getLastCudaError("launch_kernel failed");
|
||||
cudaDeviceSynchronize();
|
||||
getLastCudaError("launch_kernel failed");
|
||||
|
||||
cudaMemcpy(imageData, d_vbo_buffer, mesh_width * mesh_height * sizeof(float),
|
||||
cudaMemcpyDeviceToHost);
|
||||
cudaMemcpy(imageData, d_vbo_buffer, mesh_width * mesh_height * sizeof(float), cudaMemcpyDeviceToHost);
|
||||
|
||||
sdkDumpBin2(imageData, mesh_width * mesh_height * sizeof(float),
|
||||
"simpleGL.bin");
|
||||
reference_file = sdkFindFilePath(ref_file, argv[0]);
|
||||
sdkDumpBin2(imageData, mesh_width * mesh_height * sizeof(float), "simpleGL.bin");
|
||||
reference_file = sdkFindFilePath(ref_file, argv[0]);
|
||||
|
||||
if (reference_file &&
|
||||
!sdkCompareBin2BinFloat("simpleGL.bin", reference_file,
|
||||
mesh_width * mesh_height * sizeof(float),
|
||||
MAX_EPSILON_ERROR, THRESHOLD, pArgv[0])) {
|
||||
g_TotalErrors++;
|
||||
}
|
||||
if (reference_file
|
||||
&& !sdkCompareBin2BinFloat("simpleGL.bin",
|
||||
reference_file,
|
||||
mesh_width * mesh_height * sizeof(float),
|
||||
MAX_EPSILON_ERROR,
|
||||
THRESHOLD,
|
||||
pArgv[0])) {
|
||||
g_TotalErrors++;
|
||||
}
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
//! Display callback
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
void display_thisframe(float time_delta) {
|
||||
sdkStartTimer(&timer);
|
||||
void display_thisframe(float time_delta)
|
||||
{
|
||||
sdkStartTimer(&timer);
|
||||
|
||||
// run CUDA kernel to generate vertex positions
|
||||
runCuda(&cuda_vbo_resource);
|
||||
// run CUDA kernel to generate vertex positions
|
||||
runCuda(&cuda_vbo_resource);
|
||||
|
||||
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
||||
// GET_GLERROR(0);
|
||||
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
||||
// GET_GLERROR(0);
|
||||
|
||||
// set view matrix: broken, it doesn't work in OpenGL ES! Must put into shader
|
||||
// glMatrixMode(GL_MODELVIEW);
|
||||
// glLoadIdentity();
|
||||
// glTranslatef(0.0, 0.0, translate_z);
|
||||
// glRotatef(rotate_x, 1.0, 0.0, 0.0);
|
||||
// glRotatef(rotate_y, 0.0, 1.0, 0.0);
|
||||
// set view matrix: broken, it doesn't work in OpenGL ES! Must put into shader
|
||||
// glMatrixMode(GL_MODELVIEW);
|
||||
// glLoadIdentity();
|
||||
// glTranslatef(0.0, 0.0, translate_z);
|
||||
// glRotatef(rotate_x, 1.0, 0.0, 0.0);
|
||||
// glRotatef(rotate_y, 0.0, 1.0, 0.0);
|
||||
|
||||
glDrawArrays(GL_POINTS, 0, mesh_width * mesh_height);
|
||||
glDrawArrays(GL_POINTS, 0, mesh_width * mesh_height);
|
||||
|
||||
// GET_GLERROR(0);
|
||||
glFinish();
|
||||
// GET_GLERROR(0);
|
||||
// GET_GLERROR(0);
|
||||
glFinish();
|
||||
// GET_GLERROR(0);
|
||||
|
||||
g_fAnim += time_delta;
|
||||
g_fAnim += time_delta;
|
||||
|
||||
sdkStopTimer(&timer);
|
||||
computeFPS();
|
||||
sdkStopTimer(&timer);
|
||||
computeFPS();
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
//! Check if the result is correct or write data to file for external
|
||||
//! regression testing
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
void checkResultCuda(int argc, char **argv, const GLuint &vbo) {
|
||||
if (!d_vbo_buffer) {
|
||||
printf("%s: Mapping result buffer from OpenGL ES\n", __FUNCTION__);
|
||||
void checkResultCuda(int argc, char **argv, const GLuint &vbo)
|
||||
{
|
||||
if (!d_vbo_buffer) {
|
||||
printf("%s: Mapping result buffer from OpenGL ES\n", __FUNCTION__);
|
||||
|
||||
cudaGraphicsUnregisterResource(cuda_vbo_resource);
|
||||
cudaGraphicsUnregisterResource(cuda_vbo_resource);
|
||||
|
||||
// map buffer object
|
||||
glBindBuffer(GL_ARRAY_BUFFER, vbo);
|
||||
float *data = (float *)glMapBufferRange(
|
||||
GL_ARRAY_BUFFER, 0, mesh_width * mesh_height * 4 * sizeof(float),
|
||||
GL_READ_ONLY);
|
||||
// map buffer object
|
||||
glBindBuffer(GL_ARRAY_BUFFER, vbo);
|
||||
float *data =
|
||||
(float *)glMapBufferRange(GL_ARRAY_BUFFER, 0, mesh_width * mesh_height * 4 * sizeof(float), GL_READ_ONLY);
|
||||
|
||||
// check result
|
||||
if (checkCmdLineFlag(argc, (const char **)argv, "regression")) {
|
||||
// write file for regression test
|
||||
sdkWriteFile<float>("./data/regression.dat", data,
|
||||
mesh_width * mesh_height * 3, 0.0, false);
|
||||
// check result
|
||||
if (checkCmdLineFlag(argc, (const char **)argv, "regression")) {
|
||||
// write file for regression test
|
||||
sdkWriteFile<float>("./data/regression.dat", data, mesh_width * mesh_height * 3, 0.0, false);
|
||||
}
|
||||
|
||||
// unmap GL buffer object
|
||||
if (!glUnmapBuffer(GL_ARRAY_BUFFER)) {
|
||||
fprintf(stderr, "Unmap buffer failed.\n");
|
||||
fflush(stderr);
|
||||
}
|
||||
|
||||
checkCudaErrors(cudaGraphicsGLRegisterBuffer(&cuda_vbo_resource, vbo, cudaGraphicsMapFlagsWriteDiscard));
|
||||
|
||||
GET_GLERROR(0);
|
||||
}
|
||||
|
||||
// unmap GL buffer object
|
||||
if (!glUnmapBuffer(GL_ARRAY_BUFFER)) {
|
||||
fprintf(stderr, "Unmap buffer failed.\n");
|
||||
fflush(stderr);
|
||||
}
|
||||
|
||||
checkCudaErrors(cudaGraphicsGLRegisterBuffer(
|
||||
&cuda_vbo_resource, vbo, cudaGraphicsMapFlagsWriteDiscard));
|
||||
|
||||
GET_GLERROR(0);
|
||||
}
|
||||
}
|
||||
|
||||
GLuint mesh_shader = 0;
|
||||
|
||||
void readAndCompileShaderFromGLSLFile(GLuint new_shaderprogram,
|
||||
const char *filename, GLenum shaderType) {
|
||||
FILE *file = fopen(filename, "rb"); // open shader text file
|
||||
if (!file) error_exit("Filename %s does not exist\n", filename);
|
||||
void readAndCompileShaderFromGLSLFile(GLuint new_shaderprogram, const char *filename, GLenum shaderType)
|
||||
{
|
||||
FILE *file = fopen(filename, "rb"); // open shader text file
|
||||
if (!file)
|
||||
error_exit("Filename %s does not exist\n", filename);
|
||||
|
||||
/* get the size of the file and read it */
|
||||
fseek(file, 0, SEEK_END);
|
||||
GLint size = ftell(file);
|
||||
char *data = (char *)malloc(sizeof(char) * (size + 1));
|
||||
memset(data, 0, sizeof(char) * (size + 1));
|
||||
fseek(file, 0, SEEK_SET);
|
||||
size_t res = fread(data, 1, size, file);
|
||||
fclose(file);
|
||||
/* get the size of the file and read it */
|
||||
fseek(file, 0, SEEK_END);
|
||||
GLint size = ftell(file);
|
||||
char *data = (char *)malloc(sizeof(char) * (size + 1));
|
||||
memset(data, 0, sizeof(char) * (size + 1));
|
||||
fseek(file, 0, SEEK_SET);
|
||||
size_t res = fread(data, 1, size, file);
|
||||
fclose(file);
|
||||
|
||||
GLuint shader = glCreateShader(shaderType);
|
||||
glShaderSource(shader, 1, (const GLchar **)&data, &size);
|
||||
glCompileShader(shader);
|
||||
GLuint shader = glCreateShader(shaderType);
|
||||
glShaderSource(shader, 1, (const GLchar **)&data, &size);
|
||||
glCompileShader(shader);
|
||||
|
||||
GET_GLERROR(0);
|
||||
GLint compile_success = 0;
|
||||
glGetShaderiv(shader, GL_COMPILE_STATUS, &compile_success);
|
||||
GET_GLERROR(0);
|
||||
GET_GLERROR(0);
|
||||
GLint compile_success = 0;
|
||||
glGetShaderiv(shader, GL_COMPILE_STATUS, &compile_success);
|
||||
GET_GLERROR(0);
|
||||
|
||||
if (compile_success == GL_FALSE) {
|
||||
printf("Compilation of %s failed!\n Reason:\n", filename);
|
||||
if (compile_success == GL_FALSE) {
|
||||
printf("Compilation of %s failed!\n Reason:\n", filename);
|
||||
|
||||
GLint maxLength = 0;
|
||||
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &maxLength);
|
||||
GLint maxLength = 0;
|
||||
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &maxLength);
|
||||
|
||||
char errorLog[maxLength];
|
||||
glGetShaderInfoLog(shader, maxLength, &maxLength, &errorLog[0]);
|
||||
char errorLog[maxLength];
|
||||
glGetShaderInfoLog(shader, maxLength, &maxLength, &errorLog[0]);
|
||||
|
||||
printf("%s", errorLog);
|
||||
printf("%s", errorLog);
|
||||
|
||||
glDeleteShader(shader);
|
||||
exit(1);
|
||||
}
|
||||
glDeleteShader(shader);
|
||||
exit(1);
|
||||
}
|
||||
|
||||
glAttachShader(new_shaderprogram, shader);
|
||||
glDeleteShader(shader); // good to do?
|
||||
glAttachShader(new_shaderprogram, shader);
|
||||
glDeleteShader(shader); // good to do?
|
||||
|
||||
free(data);
|
||||
free(data);
|
||||
}
|
||||
|
||||
GLuint ShaderCreate(const char *vshader_filename,
|
||||
const char *fshader_filename) {
|
||||
printf("Loading GLSL shaders %s %s\n", vshader_filename, fshader_filename);
|
||||
GLuint ShaderCreate(const char *vshader_filename, const char *fshader_filename)
|
||||
{
|
||||
printf("Loading GLSL shaders %s %s\n", vshader_filename, fshader_filename);
|
||||
|
||||
GLuint new_shaderprogram = glCreateProgram();
|
||||
GLuint new_shaderprogram = glCreateProgram();
|
||||
|
||||
GET_GLERROR(0);
|
||||
if (vshader_filename)
|
||||
readAndCompileShaderFromGLSLFile(new_shaderprogram, vshader_filename,
|
||||
GL_VERTEX_SHADER);
|
||||
GET_GLERROR(0);
|
||||
if (vshader_filename)
|
||||
readAndCompileShaderFromGLSLFile(new_shaderprogram, vshader_filename, GL_VERTEX_SHADER);
|
||||
|
||||
GET_GLERROR(0);
|
||||
if (fshader_filename)
|
||||
readAndCompileShaderFromGLSLFile(new_shaderprogram, fshader_filename,
|
||||
GL_FRAGMENT_SHADER);
|
||||
GET_GLERROR(0);
|
||||
if (fshader_filename)
|
||||
readAndCompileShaderFromGLSLFile(new_shaderprogram, fshader_filename, GL_FRAGMENT_SHADER);
|
||||
|
||||
GET_GLERROR(0);
|
||||
GET_GLERROR(0);
|
||||
|
||||
glLinkProgram(new_shaderprogram);
|
||||
glLinkProgram(new_shaderprogram);
|
||||
|
||||
GET_GLERROR(0);
|
||||
GLint link_success;
|
||||
glGetProgramiv(new_shaderprogram, GL_LINK_STATUS, &link_success);
|
||||
GET_GLERROR(0);
|
||||
GLint link_success;
|
||||
glGetProgramiv(new_shaderprogram, GL_LINK_STATUS, &link_success);
|
||||
|
||||
if (link_success == GL_FALSE) {
|
||||
printf("Linking of %s with %s failed!\n Reason:\n", vshader_filename,
|
||||
fshader_filename);
|
||||
if (link_success == GL_FALSE) {
|
||||
printf("Linking of %s with %s failed!\n Reason:\n", vshader_filename, fshader_filename);
|
||||
|
||||
GLint maxLength = 0;
|
||||
glGetShaderiv(new_shaderprogram, GL_INFO_LOG_LENGTH, &maxLength);
|
||||
GLint maxLength = 0;
|
||||
glGetShaderiv(new_shaderprogram, GL_INFO_LOG_LENGTH, &maxLength);
|
||||
|
||||
char errorLog[maxLength];
|
||||
glGetShaderInfoLog(new_shaderprogram, maxLength, &maxLength, &errorLog[0]);
|
||||
char errorLog[maxLength];
|
||||
glGetShaderInfoLog(new_shaderprogram, maxLength, &maxLength, &errorLog[0]);
|
||||
|
||||
printf("%s", errorLog);
|
||||
printf("%s", errorLog);
|
||||
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
return new_shaderprogram;
|
||||
return new_shaderprogram;
|
||||
}
|
||||
|
||||
//===========================================================================
|
||||
// InitGraphicsState() - initialize OpenGL
|
||||
//===========================================================================
|
||||
static void InitGraphicsState(char **argv) {
|
||||
char *GL_version = (char *)glGetString(GL_VERSION);
|
||||
char *GL_vendor = (char *)glGetString(GL_VENDOR);
|
||||
char *GL_renderer = (char *)glGetString(GL_RENDERER);
|
||||
static void InitGraphicsState(char **argv)
|
||||
{
|
||||
char *GL_version = (char *)glGetString(GL_VERSION);
|
||||
char *GL_vendor = (char *)glGetString(GL_VENDOR);
|
||||
char *GL_renderer = (char *)glGetString(GL_RENDERER);
|
||||
|
||||
printf("Version: %s\n", GL_version);
|
||||
printf("Vendor: %s\n", GL_vendor);
|
||||
printf("Renderer: %s\n", GL_renderer);
|
||||
printf("Version: %s\n", GL_version);
|
||||
printf("Vendor: %s\n", GL_vendor);
|
||||
printf("Renderer: %s\n", GL_renderer);
|
||||
|
||||
// RENDERING SETUP (OpenGL ES or OpenGL Core Profile!)
|
||||
glGenVertexArrays(1, &mesh_vao); // Features' Vertex Array Object allocation
|
||||
glBindVertexArray(mesh_vao); // bind VAO
|
||||
// RENDERING SETUP (OpenGL ES or OpenGL Core Profile!)
|
||||
glGenVertexArrays(1, &mesh_vao); // Features' Vertex Array Object allocation
|
||||
glBindVertexArray(mesh_vao); // bind VAO
|
||||
|
||||
// initialize buffer object
|
||||
glGenBuffers(1, &mesh_vbo);
|
||||
glBindBuffer(GL_ARRAY_BUFFER, mesh_vbo);
|
||||
// initialize buffer object
|
||||
glGenBuffers(1, &mesh_vbo);
|
||||
glBindBuffer(GL_ARRAY_BUFFER, mesh_vbo);
|
||||
|
||||
unsigned int size = mesh_width * mesh_height * 4 * sizeof(float);
|
||||
glBufferData(GL_ARRAY_BUFFER, size, NULL, GL_DYNAMIC_DRAW);
|
||||
glVertexAttribPointer((GLuint)0, 4, GL_FLOAT, GL_FALSE, 0, 0);
|
||||
glEnableVertexAttribArray(0);
|
||||
unsigned int size = mesh_width * mesh_height * 4 * sizeof(float);
|
||||
glBufferData(GL_ARRAY_BUFFER, size, NULL, GL_DYNAMIC_DRAW);
|
||||
glVertexAttribPointer((GLuint)0, 4, GL_FLOAT, GL_FALSE, 0, 0);
|
||||
glEnableVertexAttribArray(0);
|
||||
|
||||
checkCudaErrors(cudaGraphicsGLRegisterBuffer(&cuda_vbo_resource, mesh_vbo,
|
||||
cudaGraphicsMapFlagsNone));
|
||||
checkCudaErrors(cudaGraphicsGLRegisterBuffer(&cuda_vbo_resource, mesh_vbo, cudaGraphicsMapFlagsNone));
|
||||
|
||||
// glBindVertexArray(0); // keep above Vertex Array Object bound (it's the
|
||||
// only one throughout)
|
||||
// glBindVertexArray(0); // keep above Vertex Array Object bound (it's the
|
||||
// only one throughout)
|
||||
|
||||
// GLSL stuff
|
||||
char *vertex_shader_path = sdkFindFilePath("mesh.vert.glsl", argv[0]);
|
||||
char *fragment_shader_path = sdkFindFilePath("mesh.frag.glsl", argv[0]);
|
||||
// GLSL stuff
|
||||
char *vertex_shader_path = sdkFindFilePath("mesh.vert.glsl", argv[0]);
|
||||
char *fragment_shader_path = sdkFindFilePath("mesh.frag.glsl", argv[0]);
|
||||
|
||||
if (vertex_shader_path == NULL || fragment_shader_path == NULL) {
|
||||
printf("Error finding shader file\n");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
if (vertex_shader_path == NULL || fragment_shader_path == NULL) {
|
||||
printf("Error finding shader file\n");
|
||||
exit(EXIT_FAILURE);
|
||||
}
|
||||
|
||||
mesh_shader = ShaderCreate(vertex_shader_path, fragment_shader_path);
|
||||
GET_GLERROR(0);
|
||||
mesh_shader = ShaderCreate(vertex_shader_path, fragment_shader_path);
|
||||
GET_GLERROR(0);
|
||||
|
||||
free(vertex_shader_path);
|
||||
free(fragment_shader_path);
|
||||
free(vertex_shader_path);
|
||||
free(fragment_shader_path);
|
||||
|
||||
glUseProgram(mesh_shader);
|
||||
glUseProgram(mesh_shader);
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
//! Run a simple test for CUDA
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
bool runTest(int argc, char **argv, char *ref_file) {
|
||||
// Create the CUTIL timer
|
||||
sdkCreateTimer(&timer);
|
||||
bool runTest(int argc, char **argv, char *ref_file)
|
||||
{
|
||||
// Create the CUTIL timer
|
||||
sdkCreateTimer(&timer);
|
||||
|
||||
int devID = 0;
|
||||
int devID = 0;
|
||||
#if defined(__aarch64__) || defined(__arm__)
|
||||
// find iGPU on the system which is compute capable which will perform
|
||||
// GLES-CUDA interop
|
||||
devID = findIntegratedGPU();
|
||||
// find iGPU on the system which is compute capable which will perform
|
||||
// GLES-CUDA interop
|
||||
devID = findIntegratedGPU();
|
||||
#else
|
||||
// use command-line specified CUDA device, otherwise use device with highest
|
||||
// Gflops/s
|
||||
devID = findCudaDevice(argc, (const char **)argv);
|
||||
// use command-line specified CUDA device, otherwise use device with highest
|
||||
// Gflops/s
|
||||
devID = findCudaDevice(argc, (const char **)argv);
|
||||
#endif
|
||||
|
||||
// command line mode only
|
||||
if (ref_file != NULL) {
|
||||
// create VBO
|
||||
checkCudaErrors(cudaMalloc((void **)&d_vbo_buffer,
|
||||
mesh_width * mesh_height * 4 * sizeof(float)));
|
||||
// command line mode only
|
||||
if (ref_file != NULL) {
|
||||
// create VBO
|
||||
checkCudaErrors(cudaMalloc((void **)&d_vbo_buffer, mesh_width * mesh_height * 4 * sizeof(float)));
|
||||
|
||||
// run the cuda part
|
||||
runAutoTest(devID, argv, ref_file);
|
||||
// run the cuda part
|
||||
runAutoTest(devID, argv, ref_file);
|
||||
|
||||
// check result of Cuda step
|
||||
checkResultCuda(argc, argv, mesh_vbo);
|
||||
// check result of Cuda step
|
||||
checkResultCuda(argc, argv, mesh_vbo);
|
||||
|
||||
cudaFree(d_vbo_buffer);
|
||||
d_vbo_buffer = NULL;
|
||||
} else {
|
||||
// this would use command-line specified CUDA device, note that CUDA
|
||||
// defaults to highest Gflops/s device
|
||||
if (checkCmdLineFlag(argc, (const char **)argv, "device"))
|
||||
error_exit("Device setting not yet implemented!\n");
|
||||
cudaFree(d_vbo_buffer);
|
||||
d_vbo_buffer = NULL;
|
||||
}
|
||||
else {
|
||||
// this would use command-line specified CUDA device, note that CUDA
|
||||
// defaults to highest Gflops/s device
|
||||
if (checkCmdLineFlag(argc, (const char **)argv, "device"))
|
||||
error_exit("Device setting not yet implemented!\n");
|
||||
|
||||
// create X11 window and set up associated OpenGL ES context
|
||||
graphics_setup_window(0, 0, window_width, window_height, sSDKsample);
|
||||
// create X11 window and set up associated OpenGL ES context
|
||||
graphics_setup_window(0, 0, window_width, window_height, sSDKsample);
|
||||
|
||||
InitGraphicsState(argv); // set up GLES stuff
|
||||
InitGraphicsState(argv); // set up GLES stuff
|
||||
|
||||
glClearColor(0, 0.5, 1, 1); // blue-ish background
|
||||
glClear(GL_COLOR_BUFFER_BIT);
|
||||
glClearColor(0, 0.5, 1, 1); // blue-ish background
|
||||
glClear(GL_COLOR_BUFFER_BIT);
|
||||
|
||||
// printf("WP%d\n", __LINE__);
|
||||
graphics_swap_buffers();
|
||||
// printf("WP%d\n", __LINE__);
|
||||
graphics_swap_buffers();
|
||||
|
||||
int frame = 0;
|
||||
int frame = 0;
|
||||
|
||||
while (frame < 1000) {
|
||||
display_thisframe(0.010);
|
||||
usleep(1000); // need not take full CPU and GPU
|
||||
while (frame < 1000) {
|
||||
display_thisframe(0.010);
|
||||
usleep(1000); // need not take full CPU and GPU
|
||||
|
||||
graphics_swap_buffers();
|
||||
// printf("frame %d\n",frame++);
|
||||
graphics_swap_buffers();
|
||||
// printf("frame %d\n",frame++);
|
||||
}
|
||||
|
||||
// NOTE: Before destroying OpenGL ES context, must unregister all shared
|
||||
// resources from CUDA !
|
||||
cudaGraphicsUnregisterResource(cuda_vbo_resource);
|
||||
|
||||
graphics_close_window(); // close window and destroy OpenGL ES context
|
||||
|
||||
sdkDeleteTimer(&timer);
|
||||
}
|
||||
|
||||
// NOTE: Before destroying OpenGL ES context, must unregister all shared
|
||||
// resources from CUDA !
|
||||
cudaGraphicsUnregisterResource(cuda_vbo_resource);
|
||||
|
||||
graphics_close_window(); // close window and destroy OpenGL ES context
|
||||
|
||||
sdkDeleteTimer(&timer);
|
||||
}
|
||||
|
||||
return true;
|
||||
return true;
|
||||
}
|
||||
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
// Program main
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
int main(int argc, char **argv) {
|
||||
char *ref_file = NULL;
|
||||
int main(int argc, char **argv)
|
||||
{
|
||||
char *ref_file = NULL;
|
||||
|
||||
pArgc = &argc;
|
||||
pArgv = argv;
|
||||
pArgc = &argc;
|
||||
pArgv = argv;
|
||||
|
||||
#if defined(__linux__)
|
||||
setenv("DISPLAY", ":0", 0);
|
||||
setenv("DISPLAY", ":0", 0);
|
||||
#endif
|
||||
|
||||
printf("%s starting...\n", sSDKsample);
|
||||
printf("%s starting...\n", sSDKsample);
|
||||
|
||||
if (argc > 1) {
|
||||
if (checkCmdLineFlag(argc, (const char **)argv, "file")) {
|
||||
// In this mode, we run without OpenGL and see if VBO is generated
|
||||
// correctly
|
||||
getCmdLineArgumentString(argc, (const char **)argv, "file",
|
||||
(char **)&ref_file);
|
||||
if (argc > 1) {
|
||||
if (checkCmdLineFlag(argc, (const char **)argv, "file")) {
|
||||
// In this mode, we run without OpenGL and see if VBO is generated
|
||||
// correctly
|
||||
getCmdLineArgumentString(argc, (const char **)argv, "file", (char **)&ref_file);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
printf("\n");
|
||||
printf("\n");
|
||||
|
||||
runTest(argc, argv, ref_file);
|
||||
runTest(argc, argv, ref_file);
|
||||
|
||||
printf("%s completed, returned %s\n", sSDKsample,
|
||||
(g_TotalErrors == 0) ? "OK" : "ERROR!");
|
||||
printf("%s completed, returned %s\n", sSDKsample, (g_TotalErrors == 0) ? "OK" : "ERROR!");
|
||||
|
||||
exit(g_TotalErrors == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
|
||||
exit(g_TotalErrors == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user