NASP/cuda-samples
84
0
Fork 0
mirror of https://github.com/NVIDIA/cuda-samples.git synced 2026-10-13 00:08:26 +08:00
Code Issues Packages Projects Releases Wiki Activity

CUDA 13.2 samples update (#432)

Browse Source 
- Added Python samples for CUDA Python 1.0 release
- Renamed top-level `Samples` directory to `cpp` to accommodate Python samples.
This commit is contained in:
Dheemanth
2026-05-13 15:13:18 -07:00
committed by GitHub
parent a4526d5229
commit aeab82ff30
2072 changed files with 15077 additions and 1970 deletions
Download Patch File Download Diff File Expand all files Collapse all files

18
cpp/8_Platform_Specific/Tegra/simpleGLES_EGLOutput/.vscode/c_cpp_properties.json vendored Normal file
View File

@@ -0,0 +1,18 @@
{
"configurations": [
{
"name": "Linux",
"includePath": [
"${workspaceFolder}/**",
"${workspaceFolder}/../../../Common"
],
"defines": [],
"compilerPath": "/usr/local/cuda/bin/nvcc",
"cStandard": "gnu17",
"cppStandard": "gnu++14",
"intelliSenseMode": "linux-gcc-x64",
"configurationProvider": "ms-vscode.makefile-tools"
}
],
"version": 4
}

7
cpp/8_Platform_Specific/Tegra/simpleGLES_EGLOutput/.vscode/extensions.json vendored Normal file
View File

@@ -0,0 +1,7 @@
{
"recommendations": [
"nvidia.nsight-vscode-edition",
"ms-vscode.cpptools",
"ms-vscode.makefile-tools"
]
}

82
cpp/8_Platform_Specific/Tegra/simpleGLES_EGLOutput/CMakeLists.txt Normal file
View File

@@ -0,0 +1,82 @@
cmake_minimum_required(VERSION 3.20)
list(APPEND CMAKE_MODULE_PATH "${CMAKE_CURRENT_SOURCE_DIR}/../../../../cmake/Modules")
project(simpleGLES_EGLOutput LANGUAGES C CXX CUDA)
find_package(CUDAToolkit REQUIRED)
set(CMAKE_POSITION_INDEPENDENT_CODE ON)
set(CMAKE_CUDA_ARCHITECTURES 87 110)
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -Wno-deprecated-gpu-targets")
if(ENABLE_CUDA_DEBUG)
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -G") # enable cuda-gdb (may significantly affect performance on some targets)
else()
set(CMAKE_CUDA_FLAGS "${CMAKE_CUDA_FLAGS} -lineinfo") # add line information to all builds for debug tools (exclusive to -G option)
endif()
# Include directories and libraries
include_directories(../../../../Common)
find_package(EGL)
find_package(X11)
find_package(OpenGL)
if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
if(${OpenGL_FOUND})
if(${EGL_FOUND})
if(${X11_FOUND})
set(DRM_INCLUDE_PATH "/usr/include/drm" "/usr/include/libdrm" ${CMAKE_INCLUDE_PATH})
# use CMAKE_LIBRARY_PATH so that users can also specify the NVSCI lib path in cmake command
set(CMAKE_LIBRARY_PATH "/usr/lib/${CMAKE_SYSTEM_PROCESSOR}-linux-gnu" ${CMAKE_LIBRARY_PATH})
find_library(DRM_LIB drm PATHS ${CMAKE_LIBRARY_PATH})
# Source file
# Add target for simpleGLES_EGLOutput
add_executable(simpleGLES_EGLOutput simpleGLES_EGLOutput.cu)
target_compile_options(simpleGLES_EGLOutput PRIVATE $<$<COMPILE_LANGUAGE:CUDA>:--extended-lambda>)
target_compile_features(simpleGLES_EGLOutput PRIVATE cxx_std_17 cuda_std_17)
set_target_properties(simpleGLES_EGLOutput PROPERTIES CUDA_SEPARABLE_COMPILATION ON)
target_include_directories(simpleGLES_EGLOutput PUBLIC
${EGL_INCLUDE_DIR}
${OPENGL_INCLUDE_DIR}
${CUDAToolkit_INCLUDE_DIR}
${DRM_INCLUDE_PATH}
)
target_link_libraries(simpleGLES_EGLOutput
${EGL_LIBRARY}
${X11_LIBRARIES}
${OPENGL_LIBRARIES}
${DRM_LIB}
)
# Copy the .glsl files to the output directory
add_custom_command(TARGET simpleGLES_EGLOutput POST_BUILD
COMMAND ${CMAKE_COMMAND} -E copy_if_different
${CMAKE_CURRENT_SOURCE_DIR}/mesh.frag.glsl
${CMAKE_CURRENT_SOURCE_DIR}/mesh.vert.glsl
${CMAKE_CURRENT_BINARY_DIR}
)
else()
message(STATUS "X11 libraries not found - will not build sample 'simpleGLES_EGLOutput'")
endif()
else()
message(STATUS "EGL not found - will not build sample 'simpleGLES_EGLOutput'")
endif()
else()
message(STATUS "OpenGL not found - will not build sample 'simpleGLES_EGLOutput'")
endif()
else()
message(STATUS "Will not build sample simpleGLES_EGLOutput - requires Linux OS")
endif()
# Include installation configuration
include(${CMAKE_CURRENT_SOURCE_DIR}/../../../../cmake/InstallSamples.cmake)
setup_samples_install()

41
cpp/8_Platform_Specific/Tegra/simpleGLES_EGLOutput/README.md Normal file
View File

@@ -0,0 +1,41 @@
# simpleGLES_EGLOutput - Simple OpenGLES EGLOutput
## Description
Demonstrates data exchange between CUDA and OpenGL ES (aka Graphics interop). The program modifies vertex positions with CUDA and uses OpenGL ES to render the geometry, and shows how to render directly to the display using the EGLOutput mechanism and the DRM library.
```
NOTE: On Orin platform, execute this command before running sample:
$ sudo modprobe nvidia-drm modeset=1
```
## Key Concepts
Graphics Interop, Vertex Buffers, 3D Graphics
## Supported SM Architectures
[SM 5.0 ](https://developer.nvidia.com/cuda-gpus) [SM 5.2 ](https://developer.nvidia.com/cuda-gpus) [SM 5.3 ](https://developer.nvidia.com/cuda-gpus) [SM 6.0 ](https://developer.nvidia.com/cuda-gpus) [SM 6.1 ](https://developer.nvidia.com/cuda-gpus) [SM 7.0 ](https://developer.nvidia.com/cuda-gpus) [SM 7.2 ](https://developer.nvidia.com/cuda-gpus) [SM 7.5 ](https://developer.nvidia.com/cuda-gpus) [SM 8.0 ](https://developer.nvidia.com/cuda-gpus) [SM 8.6 ](https://developer.nvidia.com/cuda-gpus) [SM 8.7 ](https://developer.nvidia.com/cuda-gpus) [SM 8.9 ](https://developer.nvidia.com/cuda-gpus) [SM 9.0 ](https://developer.nvidia.com/cuda-gpus)
## Supported OSes
Linux
## Supported CPU Architecture
armv7l
## CUDA APIs involved
### [CUDA Runtime API](http://docs.nvidia.com/cuda/cuda-runtime-api/index.html)
cudaGraphicsUnmapResources, cudaMemcpy, cudaFree, cudaGraphicsResourceGetMappedPointer, cudaGraphicsMapResources, cudaDeviceSynchronize, cudaGraphicsUnregisterResource, cudaMalloc, cudaGraphicsGLRegisterBuffer
## Dependencies needed to build/run
[EGLOutput](../../../README.md#egloutput), [OpenGL ES](../../../README.md#opengl-es)
## Prerequisites
Download and install the [CUDA Toolkit](https://developer.nvidia.com/cuda-downloads) for your corresponding platform.
Make sure the dependencies mentioned in [Dependencies]() section above are installed.
## References (for more details)

BIN
cpp/8_Platform_Specific/Tegra/simpleGLES_EGLOutput/data/ref_simpleGLES_EGLOutput.bin Normal file
View File

Binary file not shown.

608
cpp/8_Platform_Specific/Tegra/simpleGLES_EGLOutput/graphics_interface_egloutput_via_egl.c Normal file
View File

@@ -0,0 +1,608 @@
/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of NVIDIA CORPORATION nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
// Display *display;
int screen;
// Window win = 0;
#include <GLES3/gl31.h>
#include <assert.h>
#include <drm_fourcc.h>
#include <xf86drm.h>
#include <xf86drmMode.h>
// #include <GLES3/gl3ext.h> // not (yet) needed
#include <EGL/egl.h>
#include <EGL/eglext.h>
#include <fcntl.h>
#include <sys/stat.h>
#include <sys/types.h>
#define MAX_DEVICES 16
static PFNEGLQUERYDEVICESEXTPROC eglQueryDevicesEXT = NULL;
static PFNEGLQUERYDEVICESTRINGEXTPROC eglQueryDeviceStringEXT = NULL;
static PFNEGLGETPLATFORMDISPLAYEXTPROC eglGetPlatformDisplayEXT = NULL;
static PFNEGLGETOUTPUTLAYERSEXTPROC eglGetOutputLayersEXT = NULL;
static PFNEGLCREATESTREAMKHRPROC eglCreateStreamKHR = NULL;
static PFNEGLDESTROYSTREAMKHRPROC eglDestroyStreamKHR = NULL;
static PFNEGLSTREAMCONSUMEROUTPUTEXTPROC eglStreamConsumerOutputEXT = NULL;
static PFNEGLCREATESTREAMPRODUCERSURFACEKHRPROC eglCreateStreamProducerSurfaceKHR = NULL;
#define GET_GLERROR(ret) \
{ \
GLenum err = glGetError(); \
if (err != GL_NO_ERROR) { \
fprintf(stderr, "[%s line %d] OpenGL Error: 0x%x\n", __FILE__, __LINE__, err); \
fflush(stderr); \
\
switch (err) { \
case GL_INVALID_ENUM: \
printf("GL_INVALID_ENUM\n"); \
break; \
case GL_INVALID_VALUE: \
printf("GL_INVALID_VALUE\n"); \
break; \
case GL_INVALID_OPERATION: \
printf("GL_INVALID_OPERATION\n"); \
break; \
case GL_OUT_OF_MEMORY: \
printf("GL_OUT_OF_MEMORY\n"); \
break; \
case GL_INVALID_FRAMEBUFFER_OPERATION: \
printf("GL_INVALID_FRAMEBUFFER_OPERATION\n"); \
break; \
default: \
printf("UKNOWN OPENGL ERROR CODE 0x%x\n", err); \
}; \
} \
}
EGLDisplay eglDisplay = EGL_NO_DISPLAY;
EGLSurface eglSurface = EGL_NO_SURFACE;
EGLContext eglContext = EGL_NO_CONTEXT;
#if 0 // needed for optional API call retrieval (= if libGLESv2.so wouldn't be
// linked explicitly) - tedious! consider GLEW.
typedef GLenum (* glGetErrorTYPE) (void);
glGetErrorTYPE my_glGetError;
typedef GL_APICALL const GLubyte (*GL_APIENTRY glGetStringTYPE) (GLenum name);
glGetStringTYPE my_glGetString;
typedef GL_APICALL void (*GL_APIENTRY glClearTYPE) (GLbitfield mask);
glClearTYPE my_glClear;
typedef GL_APICALL void (*GL_APIENTRY glGetProgramivTYPE) (GLuint program, GLenum pname, GLint *params);
glGetProgramivTYPE my_glGetProgramiv;
#endif
// Extension checking utility
static bool CheckExtension(const char *exts, const char *ext)
{
int extLen = (int)strlen(ext);
const char *end = exts + strlen(exts);
while (exts < end) {
while (*exts == ' ') {
exts++;
}
int n = strcspn(exts, " ");
if ((extLen == n) && (strncmp(ext, exts, n) == 0)) {
return true;
}
exts += n;
}
return false;
}
int graphics_setup_window(int xpos, int ypos, int width, int height, const char *windowname)
{
int device = 0, crtc = -1, plane = -1;
int xsurfsize = 0, ysurfsize = 0;
int xoffset = 0, yoffset = 0;
int xmodesize = 0, ymodesize = 0;
// int color = 0, duration = 10;
int fifo = 0;
int bounce = 0;
uint32_t fb_id = -1;
EGLDeviceEXT egl_devs[MAX_DEVICES], egl_dev;
EGLOutputLayerEXT egl_lyr;
EGLConfig egl_cfg;
EGLStreamKHR egl_str;
EGLint major, minor;
const char *drm_name;
int drm_fd;
uint32_t drm_conn_id, drm_enc_id, drm_crtc_id, drm_plane_id;
uint32_t crtc_mask;
drmModeRes *drm_res_info = NULL;
drmModePlaneRes *drm_plane_res_info = NULL;
drmModeCrtc *drm_crtc_info = NULL;
drmModeConnector *drm_conn_info = NULL;
drmModeEncoder *drm_enc_info = NULL;
drmModePlane *drm_plane_info = NULL;
int drm_mode_index = 0;
bool set_mode = false;
int i, n;
// Load extension function pointers.
eglQueryDevicesEXT = (PFNEGLQUERYDEVICESEXTPROC)eglGetProcAddress("eglQueryDevicesEXT");
eglQueryDeviceStringEXT = (PFNEGLQUERYDEVICESTRINGEXTPROC)eglGetProcAddress("eglQueryDeviceStringEXT");
eglGetPlatformDisplayEXT = (PFNEGLGETPLATFORMDISPLAYEXTPROC)eglGetProcAddress("eglGetPlatformDisplayEXT");
eglGetOutputLayersEXT = (PFNEGLGETOUTPUTLAYERSEXTPROC)eglGetProcAddress("eglGetOutputLayersEXT");
eglCreateStreamKHR = (PFNEGLCREATESTREAMKHRPROC)eglGetProcAddress("eglCreateStreamKHR");
eglDestroyStreamKHR = (PFNEGLDESTROYSTREAMKHRPROC)eglGetProcAddress("eglDestroyStreamKHR");
eglStreamConsumerOutputEXT = (PFNEGLSTREAMCONSUMEROUTPUTEXTPROC)eglGetProcAddress("eglStreamConsumerOutputEXT");
eglCreateStreamProducerSurfaceKHR =
(PFNEGLCREATESTREAMPRODUCERSURFACEKHRPROC)eglGetProcAddress("eglCreateStreamProducerSurfaceKHR");
if (!eglQueryDevicesEXT || !eglQueryDeviceStringEXT || !eglGetPlatformDisplayEXT || !eglGetOutputLayersEXT
|| !eglCreateStreamKHR || !eglDestroyStreamKHR || !eglStreamConsumerOutputEXT
|| !eglCreateStreamProducerSurfaceKHR) {
printf("Missing required function(s)\n");
exit(2);
}
printf("Loaded extension functions\n");
// Query device
if (!eglQueryDevicesEXT(device + 1, egl_devs, &n) || (n <= device)) {
printf("Requested device index (%d) not found\n", device);
exit(2);
}
egl_dev = egl_devs[device];
// Obtain and open DRM device file
drm_name = eglQueryDeviceStringEXT(egl_dev, EGL_DRM_DEVICE_FILE_EXT);
if (!drm_name) {
printf("Couldn't obtain device file from 0x%p\n", (void *)(uintptr_t)egl_dev);
exit(3);
}
if (!strcmp(drm_name, "drm-nvdc")) {
drm_fd = drmOpen(drm_name, NULL);
}
else {
drm_fd = open(drm_name, O_RDWR, 0);
}
if (drm_fd == -1) {
printf("Couldn't open device file '%s'\n", drm_name);
exit(3);
}
printf("Device file: %s\n", drm_name);
// Obtain DRM-KMS resources
drm_res_info = drmModeGetResources(drm_fd);
if (!drm_res_info) {
printf("Couldn't obtain DRM-KMS resources\n");
exit(3);
}
printf("Obtained device information\n");
// If a specific crtc was requested, make sure it exists
if (crtc >= drm_res_info->count_crtcs) {
printf("Requested crtc index (%d) exceeds count (%d)\n", crtc, drm_res_info->count_crtcs);
exit(4);
}
crtc_mask = (crtc >= 0) ? (1 << crtc) : ((1 << drm_res_info->count_crtcs) - 1);
// If drawing to a plane is requested, obtain the plane info
if (plane >= 0) {
drm_plane_res_info = drmModeGetPlaneResources(drm_fd);
if (!drm_plane_res_info) {
printf("Unable to obtain plane resource list\n");
exit(5);
}
if (plane >= drm_plane_res_info->count_planes) {
printf("Requested plane index (%d) exceeds count (%d)\n", plane, drm_plane_res_info->count_planes);
exit(5);
}
drm_plane_id = drm_plane_res_info->planes[plane];
drm_plane_info = drmModeGetPlane(drm_fd, drm_plane_id);
if (!drm_plane_info) {
printf("Unable to obtain info for plane (%d)\n", drm_plane_id);
exit(5);
}
crtc_mask &= drm_plane_info->possible_crtcs;
if (!crtc_mask) {
printf("Requested crtc and plane not compatible\n");
exit(5);
}
printf("Obtained plane information\n");
}
// Query info for requested connector
int conn = 0;
for (conn = 0; conn < drm_res_info->count_connectors; ++conn) {
drm_conn_id = drm_res_info->connectors[conn];
drm_conn_info = drmModeGetConnector(drm_fd, drm_conn_id);
if (drm_conn_info != NULL) {
printf("connector %d found\n", drm_conn_info->connector_id);
if (drm_conn_info->connection == DRM_MODE_CONNECTED) {
break;
}
drmModeFreeConnector(drm_conn_info);
}
}
if (conn == drm_res_info->count_connectors) {
printf("No active connectors found\n");
exit(6);
}
printf("Obtained connector information\n");
// If there is already an encoder attached to the connector, choose
// it unless not compatible with crtc/plane
drm_enc_id = drm_conn_info->encoder_id;
drm_enc_info = drmModeGetEncoder(drm_fd, drm_enc_id);
if (drm_enc_info) {
if (!(drm_enc_info->possible_crtcs & crtc_mask)) {
drmModeFreeEncoder(drm_enc_info);
drm_enc_info = NULL;
}
}
// If we didn't have a suitable encoder, find one
if (!drm_enc_info) {
for (i = 0; i < drm_conn_info->count_encoders; ++i) {
drm_enc_id = drm_conn_info->encoders[i];
drm_enc_info = drmModeGetEncoder(drm_fd, drm_enc_id);
if (drm_enc_info) {
if (crtc_mask & drm_enc_info->possible_crtcs) {
crtc_mask &= drm_enc_info->possible_crtcs;
break;
}
drmModeFreeEncoder(drm_enc_info);
drm_enc_info = NULL;
}
}
if (i == drm_conn_info->count_encoders) {
printf("Unable to find suitable encoder\n");
exit(7);
}
}
printf("Obtained encoder information\n");
// Select a suitable crtc. Give preference to any that's already
// attached to the encoder. (Could make this more sophisticated
// by finding one not already bound to any other encoders. But
// this is just a basic test, so we don't really care that much.)
assert(crtc_mask);
for (i = 0; i < drm_res_info->count_crtcs; ++i) {
if (crtc_mask & (1 << i)) {
drm_crtc_id = drm_res_info->crtcs[i];
if (drm_res_info->crtcs[i] == drm_enc_info->crtc_id) {
break;
}
}
}
// Query info for crtc
drm_crtc_info = drmModeGetCrtc(drm_fd, drm_crtc_id);
if (!drm_crtc_info) {
printf("Unable to obtain info for crtc (%d)\n", drm_crtc_id);
exit(4);
}
printf("Obtained crtc information\n");
// If dimensions are specified and not using a plane, find closest mode
if ((xmodesize || ymodesize) && (plane < 0)) {
// Find best fit among available modes
int best_index = 0;
int best_fit = 0x7fffffff;
for (i = 0; i < drm_conn_info->count_modes; ++i) {
drmModeModeInfoPtr mode = drm_conn_info->modes + i;
int fit = 0;
if (xmodesize) {
fit += abs((int)mode->hdisplay - xmodesize) * (int)mode->vdisplay;
}
if (ymodesize) {
fit += abs((int)mode->vdisplay - ymodesize) * (int)mode->hdisplay;
}
if (fit < best_fit) {
best_index = i;
best_fit = fit;
}
}
// Choose this size/mode
drm_mode_index = best_index;
xmodesize = (int)drm_conn_info->modes[best_index].hdisplay;
ymodesize = (int)drm_conn_info->modes[best_index].vdisplay;
}
// We'll only set the mode if we have to. This hopefully allows
// multiple instances of this application to run, writing to
// separate planes of the same display, as long as they don't
// specifiy incompatible settings.
if ((drm_conn_info->encoder_id != drm_enc_id) || (drm_enc_info->crtc_id != drm_crtc_id)
|| !drm_crtc_info->mode_valid || ((plane < 0) && xmodesize && (xmodesize != (int)drm_crtc_info->mode.hdisplay))
|| ((plane < 0) && ymodesize && (ymodesize != (int)drm_crtc_info->mode.vdisplay))) {
set_mode = true;
}
// If dimensions haven't been specified, figure out good values to use
if (!xmodesize || !ymodesize) {
// If mode requires reset, just pick the first one available
// from the connector
if (set_mode) {
xmodesize = (int)drm_conn_info->modes[0].hdisplay;
ymodesize = (int)drm_conn_info->modes[0].vdisplay;
}
// Otherwise get it from the current crtc settings
else {
xmodesize = (int)drm_crtc_info->mode.hdisplay;
ymodesize = (int)drm_crtc_info->mode.vdisplay;
}
}
printf("Determine mode settings\n");
// If surf size is unspecified, default to fullscreen normally
// or to 1/4 fullscreen if in animated bounce mode.
if (!xsurfsize || !ysurfsize) {
if (bounce) {
xsurfsize = xmodesize / 2;
ysurfsize = ymodesize / 2;
}
else {
xsurfsize = xmodesize;
ysurfsize = ymodesize;
}
}
printf("Determine surface size\n");
// create framebuffer (required for nvidia-drm)
drmVersionPtr version = drmGetVersion(drm_fd);
if (!version) {
printf("drmGetVersion() failed..\n");
exit(1);
}
if (!strcmp(version->name, "nvidia-drm")) {
drm_mode_create_dumb prop;
memset(&prop, 0, sizeof(drm_mode_create_dumb));
prop.width = xmodesize;
prop.height = ymodesize;
prop.bpp = 32;
int res = drmIoctl(drm_fd, DRM_IOCTL_MODE_CREATE_DUMB, &prop);
if (res) {
printf("drmIoctl() failed..(%d)\n", res);
exit(1);
}
uint32_t offset = 0;
res = drmModeAddFB2(
drm_fd, xmodesize, ymodesize, DRM_FORMAT_ARGB8888, &(prop.handle), &(prop.pitch), &offset, &fb_id, 0);
if (res) {
printf("drmModeAddFB() failed..(%d)\n", res);
exit(1);
}
}
if (version) {
drmFreeVersion(version);
version = NULL;
}
// If necessary, set the mode
if (set_mode) {
drmModeSetCrtc(drm_fd, drm_crtc_id, fb_id, 0, 0, &drm_conn_id, 1, drm_conn_info->modes + drm_mode_index);
printf("Set mode\n");
}
// If plane is in use, set it
if (plane >= 0) {
drmModeSetPlane(drm_fd,
drm_plane_id,
drm_crtc_id,
fb_id,
0,
xoffset,
yoffset,
xsurfsize,
ysurfsize,
0,
0,
xsurfsize << 16,
ysurfsize << 16);
printf("Set plane configuration\n");
}
// Obtain and initialize EGLDisplay
int attr[] = {EGL_DRM_MASTER_FD_EXT, drm_fd, EGL_NONE};
eglDisplay = eglGetPlatformDisplayEXT(EGL_PLATFORM_DEVICE_EXT, (void *)egl_dev, attr);
if (eglDisplay == EGL_NO_DISPLAY) {
printf("Couldn't obtain EGLDisplay for device\n");
exit(8);
}
if (!eglInitialize(eglDisplay, &major, &minor)) {
printf("Couldn't initialize EGLDisplay (error 0x%x)\n", eglGetError());
exit(8);
}
printf("Obtained EGLDisplay\n");
// Check for stream_consumer_egloutput + output_drm support
const char *dpy_exts = eglQueryString(eglDisplay, EGL_EXTENSIONS);
const char *dev_exts = eglQueryDeviceStringEXT(egl_dev, EGL_EXTENSIONS);
if (!CheckExtension(dpy_exts, "EGL_EXT_output_base")) {
printf("Missing required extension: EGL_EXT_output_base\n");
exit(2);
}
if (!CheckExtension(dev_exts, "EGL_EXT_device_drm")) {
printf("Missing required extension: EGL_EXT_device_drm\n");
exit(2);
}
if (!CheckExtension(dpy_exts, "EGL_EXT_output_drm")) {
printf("Missing required extension: EGL_EXT_output_drm\n");
exit(2);
}
if (!CheckExtension(dpy_exts, "EGL_EXT_stream_consumer_egloutput")) {
printf("Missing required extension: EGL_EXT_stream_consumer_egloutput\n");
exit(2);
}
// Choose a config and create a context
EGLint cfg_attr[] = {
EGL_SURFACE_TYPE, EGL_STREAM_BIT_KHR, EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT, EGL_ALPHA_SIZE, 1, EGL_NONE};
if (!eglChooseConfig(eglDisplay, cfg_attr, &egl_cfg, 1, &n) || !n) {
printf("Unable to obtain config that supports stream rendering (error 0x%x)\n", eglGetError());
exit(9);
}
EGLint ctx_attr[] = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
eglBindAPI(EGL_OPENGL_ES_API);
eglContext = eglCreateContext(eglDisplay, egl_cfg, EGL_NO_CONTEXT, ctx_attr);
if (eglContext == EGL_NO_CONTEXT) {
printf("Unable to create context (error 0x%x)\n", eglGetError());
exit(9);
}
printf("Obtained EGLConfig and EGLContext\n");
// Get the layer for this crtc/plane
EGLAttrib layer_attr[] = {EGL_NONE, EGL_NONE, EGL_NONE};
if (plane >= 0) {
layer_attr[0] = EGL_DRM_PLANE_EXT;
layer_attr[1] = (EGLAttrib)drm_plane_id;
}
else {
layer_attr[0] = EGL_DRM_CRTC_EXT;
layer_attr[1] = (EGLAttrib)drm_crtc_id;
}
if (!eglGetOutputLayersEXT(eglDisplay, layer_attr, &egl_lyr, 1, &n) || !n) {
printf("Unable to obtain EGLOutputLayer for %s 0x%x\n", (plane >= 0) ? "plane" : "crtc", (int)layer_attr[1]);
exit(10);
}
printf("Obtained EGLOutputLayer\n");
// Create a stream and connect to the output
EGLint stream_attr[] = {EGL_STREAM_FIFO_LENGTH_KHR, fifo, EGL_NONE};
egl_str = eglCreateStreamKHR(eglDisplay, stream_attr);
if (egl_str == EGL_NO_STREAM_KHR) {
printf("Unable to create stream (error 0x%x)\n", eglGetError());
exit(11);
}
if (!eglStreamConsumerOutputEXT(eglDisplay, egl_str, egl_lyr)) {
printf("Unable to connect stream (error 0x%x)\n", eglGetError());
exit(11);
}
// Create a surface to feed the stream
EGLint srf_attr[] = {EGL_WIDTH, xsurfsize, EGL_HEIGHT, ysurfsize, EGL_NONE};
eglSurface = eglCreateStreamProducerSurfaceKHR(eglDisplay, egl_cfg, egl_str, srf_attr);
if (eglSurface == EGL_NO_SURFACE) {
printf("Unable to create rendering surface (error 0x%x)\n", eglGetError());
exit(12);
}
printf("Bound layer to rendering surface\n");
// Make current
if (!eglMakeCurrent(eglDisplay, eglSurface, eglSurface, eglContext)) {
printf("Unable to make context/surface current (error 0x%x)\n", eglGetError());
exit(13);
}
EGLint Context_RendererType;
eglQueryContext(eglDisplay, eglContext, EGL_CONTEXT_CLIENT_TYPE, &Context_RendererType);
#if 0
switch (Context_RendererType)
{
case EGL_OPENGL_API:
printf("Using OpenGL API\n");
break;
case EGL_OPENGL_ES_API:
printf("Using OpenGL ES API");
break;
case 0xB6D185E8:
printf("Using EGLOutput context.\n");
break;
case EGL_OPENVG_API:
error_exit("Context Query Returned OpenVG. This is Unsupported\n");
default:
error_exit("Unknown Context Type. %04X\n", Context_RendererType);
}
#endif
#if 0 // obtain API function pointers _manually_ (see function pointer
// declarations above)
my_glGetError = (glGetErrorTYPE) eglGetProcAddress("glGetError");
my_glGetString = (glGetStringTYPE) eglGetProcAddress("glGetString");
my_glGetProgramiv = (glGetProgramivTYPE) eglGetProcAddress("glGetProgramiv");
GL_APICALL void (* my_glGenBuffers) (GLsizei n, GLuint *buffers);
my_glGenBuffers = ((*) (GLsizei n, GLuint *buffers)) eglGetProcAddress("glGenBuffers");
GL_APICALL void (* my_glGetShaderInfoLog) (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog);
my_glGetShaderInfoLog = ((*) (GLuint shader, GLsizei bufSize, GLsizei *length, GLchar *infoLog)) eglGetProcAddress("glGetShaderInfoLog");
GL_APICALL void GL_APIENTRY glBindBuffer (GLenum target, GLuint buffer);
#endif
return 1;
}
void graphics_set_windowtitle(const char *windowname) { printf(" Window title would have been: %s\n", windowname); }
void graphics_swap_buffers() { eglSwapBuffers(eglDisplay, eglSurface); }
void graphics_close_window()
{
if (eglDisplay != EGL_NO_DISPLAY) {
eglMakeCurrent(eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
if (eglContext != EGL_NO_CONTEXT)
eglDestroyContext(eglDisplay, eglContext);
if (eglSurface != EGL_NO_SURFACE)
eglDestroySurface(eglDisplay, eglSurface);
eglTerminate(eglDisplay);
}
#if 0
if (plane >= 0)
drmModeSetPlane(drm_fd, drm_plane_id, drm_crtc_id, 0, 0,
xoffset, yoffset, xsurfsize, ysurfsize,
0, 0, xsurfsize << 16, ysurfsize << 16);
else
drmModeSetCrtc(drm_fd, drm_crtc_id, 0, xoffset, yoffset, &drm_conn_id, 1,
NULL);
#endif
printf("Released display resources\n");
}

31
cpp/8_Platform_Specific/Tegra/simpleGLES_EGLOutput/mesh.frag.glsl Normal file
View File

@@ -0,0 +1,31 @@
/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of NVIDIA CORPORATION nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
void main()
{
gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
}

33
cpp/8_Platform_Specific/Tegra/simpleGLES_EGLOutput/mesh.vert.glsl Normal file
View File

@@ -0,0 +1,33 @@
/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of NVIDIA CORPORATION nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
attribute vec4 position;
void main()
{
gl_Position = position;
}

571
cpp/8_Platform_Specific/Tegra/simpleGLES_EGLOutput/simpleGLES_EGLOutput.cu Normal file
View File

@@ -0,0 +1,571 @@
/* Copyright (c) 2022, NVIDIA CORPORATION. All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* * Neither the name of NVIDIA CORPORATION nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS ``AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
* CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
* EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
* PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
* PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY
* OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/*
This example demonstrates how to use the CUDA C bindings to OpenGL ES to
dynamically modify a vertex buffer using a CUDA C kernel.
The steps are:
1. Create an empty vertex buffer object (VBO)
2. Register the VBO with CUDA C
3. Map the VBO for writing from CUDA C
4. Run CUDA C kernel to modify the vertex positions
5. Unmap the VBO
6. Render the results using OpenGL ES
Host code
*/
// includes, system
#include <math.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.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);
}
#if 0
#include "graphics_interface.c"
#else
#include "graphics_interface_egloutput_via_egl.c"
#endif
#ifdef _WIN32
#define WINDOWS_LEAN_AND_MEAN
#define NOMINMAX
#include <windows.h>
#endif
// includes, cuda
#include <cuda_gl_interop.h>
#include <cuda_runtime.h>
// Utilities and timing functions
#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 <vector_types.h>
#define MAX_EPSILON_ERROR 0.0f
#define THRESHOLD 0.0f
#define REFRESH_DELAY 1 // ms
#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_height = 512;
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;
struct cudaGraphicsResource *cuda_vbo_resource;
void *d_vbo_buffer = NULL;
float g_fAnim = 0.0;
// UI / mouse controls
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;
unsigned int g_TotalErrors = 0;
// Auto-Verification Code
bool g_bQAReadback = false;
int *pArgc = NULL;
char **pArgv = NULL;
#define MAX(a, b) ((a > b) ? a : b)
////////////////////////////////////////////////////////////////////////////////
// declaration, forward
// CUDA functionality
void runCuda(struct cudaGraphicsResource **vbo_resource);
void runAutoTest(int devID, char **argv, char *ref_file);
void checkResultCuda(int argc, char **argv, const GLuint &vbo);
const char *sSDKsample = "simpleGLES (VBO)";
void computeFPS()
{
frameCount++;
fpsCount++;
if (fpsCount == fpsLimit) {
avgFPS = 1.f / (sdkGetAverageTimerValue(&timer) / 1000.f);
fpsCount = 0;
fpsLimit = (int)MAX(avgFPS, 1.f);
sdkResetTimer(&timer);
}
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;
// 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;
// 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);
}
////////////////////////////////////////////////////////////////////////////////
//! 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);
// 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);
// unmap buffer object
cudaGraphicsUnmapResources(1, vbo_resource, 0);
}
#ifdef _WIN32
#ifndef FOPEN
#define FOPEN(fHandle, filename, mode) fopen_s(&fHandle, filename, mode)
#endif
#else
#ifndef FOPEN
#define FOPEN(fHandle, filename, mode) (fHandle = fopen(filename, mode))
#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);
}
////////////////////////////////////////////////////////////////////////////////
//! 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));
// execute the kernel
launch_kernel((float4 *)d_vbo_buffer, mesh_width, mesh_height, g_fAnim);
cudaDeviceSynchronize();
getLastCudaError("launch_kernel failed");
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]);
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);
// run CUDA kernel to generate vertex positions
runCuda(&cuda_vbo_resource);
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);
glDrawArrays(GL_POINTS, 0, mesh_width * mesh_height);
// GET_GLERROR(0);
glFinish();
// GET_GLERROR(0);
g_fAnim += time_delta;
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__);
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);
// 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);
}
}
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);
/* 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);
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);
GLint maxLength = 0;
glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &maxLength);
char errorLog[maxLength];
glGetShaderInfoLog(shader, maxLength, &maxLength, &errorLog[0]);
printf("%s", errorLog);
glDeleteShader(shader);
exit(1);
}
glAttachShader(new_shaderprogram, shader);
glDeleteShader(shader); // good to do?
free(data);
}
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();
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);
glLinkProgram(new_shaderprogram);
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);
GLint maxLength = 0;
glGetShaderiv(new_shaderprogram, GL_INFO_LOG_LENGTH, &maxLength);
char errorLog[maxLength];
glGetShaderInfoLog(new_shaderprogram, maxLength, &maxLength, &errorLog[0]);
printf("%s", errorLog);
exit(EXIT_FAILURE);
}
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);
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
// 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);
checkCudaErrors(cudaGraphicsGLRegisterBuffer(&cuda_vbo_resource, mesh_vbo, cudaGraphicsMapFlagsNone));
// 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]);
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);
free(vertex_shader_path);
free(fragment_shader_path);
glUseProgram(mesh_shader);
}
////////////////////////////////////////////////////////////////////////////////
//! Run a simple test for CUDA
////////////////////////////////////////////////////////////////////////////////
bool runTest(int argc, char **argv, char *ref_file)
{
// Create the CUTIL timer
sdkCreateTimer(&timer);
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();
#else
// 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)));
// run the cuda part
runAutoTest(devID, argv, ref_file);
// 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");
// 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
glClearColor(0, 0.5, 1, 1); // blue-ish background
glClear(GL_COLOR_BUFFER_BIT);
// printf("WP%d\n", __LINE__);
graphics_swap_buffers();
int frame = 0;
while (frame < 1000) {
display_thisframe(0.010);
usleep(1000); // need not take full CPU and GPU
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);
}
return true;
}
////////////////////////////////////////////////////////////////////////////////
// Program main
////////////////////////////////////////////////////////////////////////////////
int main(int argc, char **argv)
{
char *ref_file = NULL;
pArgc = &argc;
pArgv = argv;
#if defined(__linux__)
setenv("DISPLAY", ":0", 0);
#endif
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);
}
}
printf("\n");
runTest(argc, argv, ref_file);
printf("%s completed, returned %s\n", sSDKsample, (g_TotalErrors == 0) ? "OK" : "ERROR!");
exit(g_TotalErrors == 0 ? EXIT_SUCCESS : EXIT_FAILURE);
}