void cl_select_context(cl_platform_id* platform, cl_device_id* device, cl_context* context) {
cl_int err;
#if defined (__APPLE__)
CGLContextObj kCGLContext = CGLGetCurrentContext();
CGLShareGroupObj kCGLShareGroup = CGLGetShareGroup(kCGLContext);
cl_context_properties props[] =
{
CL_CONTEXT_PROPERTY_USE_CGL_SHAREGROUP_APPLE, (cl_context_properties)kCGLShareGroup,
0
};
*context = clCreateContext(props, 0,0, NULL, NULL, &err);
#else
#ifdef UNIX
cl_context_properties props[] =
{
CL_GL_CONTEXT_KHR, (cl_context_properties)glXGetCurrentContext(),
CL_GLX_DISPLAY_KHR, (cl_context_properties)glXGetCurrentDisplay(),
CL_CONTEXT_PLATFORM, (cl_context_properties)platform,
0
};
*context = clCreateContext(props, 1, &cdDevices[uiDeviceUsed], NULL, NULL, &err);
#else // Win32
cl_context_properties props[] =
{
CL_GL_CONTEXT_KHR, (cl_context_properties)wglGetCurrentContext(),
CL_WGL_HDC_KHR, (cl_context_properties)wglGetCurrentDC(),
CL_CONTEXT_PLATFORM, (cl_context_properties)*platform,
0
};
*context = clCreateContext(props, 1, device, NULL, NULL, &err);
CHECK_ERR(err);
#endif
#endif
}
ocl_constructs * newOclConstructs(cl_uint workerSize, cl_uint groupSize, cl_bool clGlSharing){
ocl_constructs * occs = (ocl_constructs*) malloc(sizeof(ocl_constructs));
occs->platformId = NULL;
occs->deviceId = NULL;
occs->context = NULL;
occs->queue = NULL;
occs->program = NULL;
occs->buffers = NULL;
occs->kernel = NULL;
if(clGlSharing && 0){
occs->contextProperties = (cl_context_properties*)
malloc(sizeof(cl_context_properties) * 7);
occs->contextProperties[0] = CL_GL_CONTEXT_KHR;
occs->contextProperties[1] = (cl_context_properties)glXGetCurrentContext();
occs->contextProperties[2] = CL_GLX_DISPLAY_KHR;
occs->contextProperties[3] = (cl_context_properties)glXGetCurrentDisplay();
occs->contextProperties[4] = CL_CONTEXT_PLATFORM;
//occs->contextProperties[5] = (cl_context_properties)cpPlatform;
occs->contextProperties[6] = 0;
}
else occs->contextProperties = NULL;
//occs->refreshCount = 30;
return occs;
}
static int gl_thread_create(void* unused) {
int err = glXMakeCurrent(gl_thread_display, gl_thread_drawable, gl_thread_context);
if (err == 0) {
// Could not make context current
return -1;
}
int status = gl_thread_func(gl_thread_data);
Display* display = glXGetCurrentDisplay();
if (display == NULL) {
// Could not get current display
return -2;
}
GLXContext context = glXGetCurrentContext();
if (context == NULL) {
// Could not get current context
return -3;
}
err = glXMakeCurrent(display, None, NULL);
if (err == 0) {
// Could not make context current
return -4;
}
glXDestroyContext(display, context);
return status;
}
void setSwapInterval(int interval) {
if (glxewIsSupported("GLX_EXT_swap_control")) {
Display *dpy = glXGetCurrentDisplay();
GLXDrawable drawable = glXGetCurrentDrawable();
glXSwapIntervalEXT(dpy, drawable, interval);
}
}
void glfntInit(void)
{
Display *dpy;
XFontStruct *fontInfo;
Font id;
unsigned int first;
if (LettersDL!=0) return;
#ifdef SGI_CC
dpy=glXGetCurrentDisplayEXT();
#else
dpy=glXGetCurrentDisplay();
#endif
if (dpy==NULL) return;
fontInfo = XLoadQueryFont(dpy,
"-adobe-times-medium-r-normal--17-120-100-100-p-88-iso8859-1");
if (fontInfo == NULL) return;
id = fontInfo->fid;
first = fontInfo->min_char_or_byte2;
last = fontInfo->max_char_or_byte2;
if (first<32) first=32;
if (last>127) last=127;
LettersDL=glGenLists(last+1);
if (LettersDL==0) return;
glXUseXFont(id, first, last-first+1, LettersDL+first);
}
static int _GetCudaDeviceForCurrentGLContext()
{
#if defined(_WIN32)
return 0;
#elif defined(__APPLE__)
return 0;
#else // X11
// If we don't have a current GL context, then choose the device which
// matches the current X11 screen number.
Display * display = glXGetCurrentDisplay();
if (!display) {
display = XOpenDisplay(NULL);
if (display) {
int screen = DefaultScreen(display);
XCloseDisplay(display);
message("CUDA init using device for default screen: %d\n", screen);
return screen;
}
return 0;
}
// We can't use the new interop API, so use the device
// corresponding to the screen number of the current GL context.
int screen = DefaultScreen(display);
message("CUDA init using device for screen: %d\n", screen);
return screen;
#endif // X11
}
void
GarchGLXContextState::DoneCurrent()
{
if (Display* display = glXGetCurrentDisplay()) {
glXMakeCurrent(display, None, NULL);
}
}
void InitCL()
{
void* glCtx=0;
void* glDC = 0;
#ifdef _WIN32
glCtx = wglGetCurrentContext();
glDC = wglGetCurrentDC();
#elif _APPLE
glCtx = CGLGetCurrentContext();
#else //!_WIN32
glCtx = glXGetCurrentContext();
glDC = glXGetCurrentDisplay();
#endif //!_WIN32
int ciErrNum = 0;
cl_device_type deviceType = CL_DEVICE_TYPE_ALL;//GPU;
g_cxMainContext = btOpenCLUtils::createContextFromType(deviceType, &ciErrNum, glCtx, glDC);
oclCHECKERROR(ciErrNum, CL_SUCCESS);
int numDev = btOpenCLUtils::getNumDevices(g_cxMainContext);
if (numDev>0)
{
g_device= btOpenCLUtils::getDevice(g_cxMainContext,0);
btOpenCLUtils::printDeviceInfo(g_device);
// create a command-queue
g_cqCommandQue = clCreateCommandQueue(g_cxMainContext, g_device, 0, &ciErrNum);
oclCHECKERROR(ciErrNum, CL_SUCCESS);
//normally you would create and execute kernels using this command queue
}
}
static int _GetCudaDeviceForCurrentGLContext()
{
// Find and use the CUDA device for the current GL context
unsigned int interopDeviceCount = 0;
int interopDevices[1];
cudaError_t status = cudaGLGetDevices(&interopDeviceCount, interopDevices,
1, cudaGLDeviceListCurrentFrame);
if (status == cudaErrorNoDevice || interopDeviceCount != 1) {
message("CUDA no interop devices found.\n");
return 0;
}
int device = interopDevices[0];
#if defined(_WIN32)
return device;
#elif defined(__APPLE__)
return device;
#else // X11
Display * display = glXGetCurrentDisplay();
int screen = DefaultScreen(display);
if (device != screen) {
error("The CUDA interop device (%d) does not match "
"the screen used by the current GL context (%d), "
"which may cause slow performance on systems "
"with multiple GPU devices.", device, screen);
}
message("CUDA init using device for current GL context: %d\n", device);
return device;
#endif
}
static int create(struct gl_hwdec *hw)
{
GL *gl = hw->gl;
if (hw->hwctx)
return -1;
Display *x11disp = glXGetCurrentDisplay();
if (!x11disp)
return -1;
if (!(gl->mpgl_caps & MPGL_CAP_VDPAU))
return -1;
struct priv *p = talloc_zero(hw, struct priv);
hw->priv = p;
p->log = hw->log;
p->ctx = mp_vdpau_create_device_x11(hw->log, x11disp, true);
if (!p->ctx)
return -1;
if (mp_vdpau_handle_preemption(p->ctx, &p->preemption_counter) < 1)
return -1;
p->vdp_surface = VDP_INVALID_HANDLE;
p->mixer = mp_vdpau_mixer_create(p->ctx, hw->log);
if (hw->probing && mp_vdpau_guess_if_emulated(p->ctx)) {
destroy(hw);
return -1;
}
hw->hwctx = &p->ctx->hwctx;
hw->converted_imgfmt = IMGFMT_RGB0;
return 0;
}
GlfQGLPlatformDebugContextPrivate::GlfQGLPlatformDebugContextPrivate(
int majorVersion, int minorVersion,
bool coreProfile, bool directRendering)
: _dpy(NULL)
, _ctx(NULL)
{
Display *shareDisplay = glXGetCurrentDisplay();
GLXContext shareContext = glXGetCurrentContext();
int fbConfigId = 0;
glXQueryContext(shareDisplay, shareContext, GLX_FBCONFIG_ID, &fbConfigId);
int screen = 0;
glXQueryContext(shareDisplay, shareContext, GLX_SCREEN, &screen);
int configSpec[] = {
GLX_FBCONFIG_ID, fbConfigId,
None,
};
GLXFBConfig *configs = NULL;
int configCount = 0;
configs = glXChooseFBConfig(shareDisplay, screen, configSpec, &configCount);
if (not TF_VERIFY(configCount > 0)) {
return;
}
const int profile =
coreProfile
? GLX_CONTEXT_CORE_PROFILE_BIT_ARB
: GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB;
int attribs[] = {
GLX_CONTEXT_MAJOR_VERSION_ARB, majorVersion,
GLX_CONTEXT_MINOR_VERSION_ARB, minorVersion,
GLX_CONTEXT_PROFILE_MASK_ARB, profile,
GLX_CONTEXT_FLAGS_ARB, GLX_CONTEXT_DEBUG_BIT_ARB,
0,
};
// Extension entry points must be resolved at run-time.
PFNGLXCREATECONTEXTATTRIBSARBPROC createContextAttribs =
(PFNGLXCREATECONTEXTATTRIBSARBPROC)
glXGetProcAddressARB((const GLubyte*)"glXCreateContextAttribsARB");
// Create a GL context with the requested capabilities.
if (createContextAttribs) {
_ctx = (*createContextAttribs)(shareDisplay, configs[0],
shareContext, directRendering,
attribs);
} else {
TF_WARN("Unable to create GL debug context.");
XVisualInfo *vis = glXGetVisualFromFBConfig(shareDisplay, configs[0]);
_ctx = glXCreateContext(shareDisplay, vis,
shareContext, directRendering);
}
if (not TF_VERIFY(_ctx)) {
return;
}
_dpy = shareDisplay;
}
void
glx_ctx_push_thread_local(VdpDeviceData *deviceData)
{
glx_ctx_lock();
Display *dpy = deviceData->display;
const Window wnd = deviceData->root;
thread_id_t thread_id = get_current_thread_id();
ctx_stack.dpy = glXGetCurrentDisplay();
if (!ctx_stack.dpy)
ctx_stack.dpy = dpy;
ctx_stack.wnd = glXGetCurrentDrawable();
ctx_stack.glc = glXGetCurrentContext();
ctx_stack.element_count ++;
struct val_s *val = g_hash_table_lookup(glc_hash_table, GSIZE_TO_POINTER(thread_id));
if (!val) {
GLXContext glc = glXCreateContext(dpy, root_vi, root_glc, GL_TRUE);
assert(glc);
val = make_val(dpy, glc);
g_hash_table_insert(glc_hash_table, GSIZE_TO_POINTER(thread_id), val);
// try cleanup expired entries
g_hash_table_foreach_remove(glc_hash_table, is_thread_expired, NULL);
}
assert(val->dpy == dpy);
glXMakeCurrent(dpy, wnd, val->glc);
}
//
// Constructor
//
CRegistry::CRegistry(
bool WindowSystem
):
m_VersionStr( NULL ),
m_ExtensionsStr( NULL )
{
if (WindowSystem)
{
#ifdef _WIN32
if (!wglGetExtensionsStringARB)
throw Sys::CException( this, "::CRegistry() : Failed to obtain wglGetExtensionsStringARB entry point." );
HDC DC = wglGetCurrentDC();
if (!DC)
throw Sys::CException( this, "::CRegistry() : Invalid current DC." );
m_ExtensionsStr = wglGetExtensionsStringARB( DC );
#elif defined (__linux__)
Display *Dpy = glXGetCurrentDisplay();
if (!Dpy)
throw Sys::CException( this, "::CRegistry() : Invalid current Display." );
m_ExtensionsString = glXGetClientString( Dpy, GLX_EXTENSIONS );
#endif // _WIN32
}
else
{
m_VersionStr = reinterpret_cast<const char *>( glGetString( GL_VERSION ) );
m_ExtensionsStr = reinterpret_cast<const char *>( glGetString( GL_EXTENSIONS ) );
}
TokenizeString();
}
void OCLContextProperties::AddOpenGLContextProperties() {
#ifdef __linux__
cl_context_properties props[7] = {
CL_GL_CONTEXT_KHR, (cl_context_properties) glXGetCurrentContext(),
CL_GLX_DISPLAY_KHR, (cl_context_properties) glXGetCurrentDisplay(),
0
};
#elif __APPLE__
CGLContextObj kGLContext = CGLGetCurrentContext();
CGLShareGroupObj kCGLShareGroup = CGLGetShareGroup(kGLContext);
cl_context_properties props[5] = {
CL_CONTEXT_PROPERTY_USE_CGL_SHAREGROUP_APPLE, (cl_context_properties) kCGLShareGroup,
NULL
};
//foundCtx = clCreateContext(
//props, 0, 0, NULL, NULL, clerr);
#elif WIN32
cl_context_properties props[5] = {
CL_GL_CONTEXT_KHR, (cl_context_properties) wglGetCurrentContext(),
CL_WGL_HDC_KHR, (cl_context_properties) wglGetCurrentDC()
};
#else
#error "Platform Not avalible for GL intergration"
#endif
AddProperties(props);
}
// XXX: initCL should be removed from libosd
void
OsdClKernelDispatcher::initCL() {
cl_int ciErrNum;
cl_platform_id cpPlatform = 0;
cl_uint num_platforms;
ciErrNum = clGetPlatformIDs(0, NULL, &num_platforms);
if (ciErrNum != CL_SUCCESS) {
OSD_ERROR("Error %i in clGetPlatformIDs call.\n", ciErrNum);
exit(1);
}
if (num_platforms == 0) {
OSD_ERROR("No OpenCL platform found.\n");
exit(1);
}
cl_platform_id *clPlatformIDs;
clPlatformIDs = new cl_platform_id[num_platforms];
ciErrNum = clGetPlatformIDs(num_platforms, clPlatformIDs, NULL);
char chBuffer[1024];
for (cl_uint i = 0; i < num_platforms; ++i) {
ciErrNum = clGetPlatformInfo(clPlatformIDs[i], CL_PLATFORM_NAME, 1024, chBuffer,NULL);
if (ciErrNum == CL_SUCCESS) {
cpPlatform = clPlatformIDs[i];
}
}
// -------------
clGetDeviceIDs(cpPlatform, CL_DEVICE_TYPE_GPU, 1, &_clDevice, NULL);
#if defined(_WIN32)
cl_context_properties props[] = {
CL_GL_CONTEXT_KHR, (cl_context_properties)wglGetCurrentContext(),
CL_WGL_HDC_KHR, (cl_context_properties)wglGetCurrentDC(),
CL_CONTEXT_PLATFORM, (cl_context_properties)cpPlatform,
0
};
#elif defined(__APPLE__)
CGLContextObj kCGLContext = CGLGetCurrentContext();
CGLShareGroupObj kCGLShareGroup = CGLGetShareGroup(kCGLContext);
cl_context_properties props[] = {
CL_CONTEXT_PROPERTY_USE_CGL_SHAREGROUP_APPLE, (cl_context_properties)kCGLShareGroup,
0
};
#else
cl_context_properties props[] = {
CL_GL_CONTEXT_KHR, (cl_context_properties)glXGetCurrentContext(),
CL_GLX_DISPLAY_KHR, (cl_context_properties)glXGetCurrentDisplay(),
CL_CONTEXT_PLATFORM, (cl_context_properties)cpPlatform,
0
};
#endif
// XXX context creation should be moved to client code
_clContext = clCreateContext(props, 1, &_clDevice, NULL, NULL, &ciErrNum);
CL_CHECK_ERROR(ciErrNum, "clCreateContext\n");
_clQueue = clCreateCommandQueue(_clContext, _clDevice, 0, &ciErrNum);
CL_CHECK_ERROR(ciErrNum, "clCreateCommandQueue\n");
}
GarchGLXContextState::GarchGLXContextState() :
display(glXGetCurrentDisplay()),
drawable(glXGetCurrentDrawable()),
context(glXGetCurrentContext()),
_defaultCtor(true)
{
// Do nothing
}
void glx_version(int& major, int& minor)
{
#ifdef GLLOADER_GLX
glXQueryVersion(glXGetCurrentDisplay(), &major, &minor);
#else
major = minor = 0;
#endif // GLLOADER_GLX
}
/* Create a new GLC context and return its ID */
GLint glcGenContext() {
GLCcontext *c;
int i, j;
/* If this is the first call, initialize our data */
if(numGlcContexts==0) {
memset(glcContextList, 0, sizeof(glcContextList));
memset(glcContexts, 0, sizeof(glcContexts));
}
isFirstCall = FALSE;
/* Find context that is not in use */
for(j = 1; j < MAX_GLC_CONTEXTS; j++)
if(!glcContexts[j].isContext) break;
if(j == MAX_GLC_CONTEXTS) return 0;
/* Add this context to the list */
glcContextList[numGlcContexts++] = j;
glcContextList[numGlcContexts] = 0;
/* Initialize this context */
c = &glcContexts[j];
c->isContext = TRUE;
c->display = (Display*)glXGetCurrentDisplay();
c->bitmap_matrix[0] = 1.0;
c->bitmap_matrix[1] = 0.0;
c->bitmap_matrix[2] = 0.0;
c->bitmap_matrix[3] = 1.0;
c->bitmap_scale[0] = 1.0;
c->bitmap_scale[1] = 1.0;
last_error = GLC_NONE;
c->data_pointer = 0;
c->num_fonts = 0;
c->list_base = glGenLists(256);
c->reload_font = TRUE;
c->scale_change = TRUE;
memcpy(c->bitmap_matrix, identity_matrix_2_by_2, sizeof(c->bitmap_matrix));
/* Turn on synchronization. This does not affear to affect performance,
* and seems to keep my X server from crashing. Still, this should
* not be necessary, and an alternative solution would probably be
* preferable.
*/
XSynchronize(c->display, TRUE);
/* Load a default font */
memset(c->font_list, 0, sizeof(c->font_list));
c->fonts[0][GLC_STYLE_NORMAL].xfontinfo = XLoadQueryFont(c->display, "variable");
c->fonts[0][GLC_STYLE_NORMAL].xfont = c->fonts[0][GLC_STYLE_NORMAL].xfontinfo->fid;
c->fonts[0][GLC_STYLE_NORMAL].name = strdup("base");
c->fonts[0][GLC_STYLE_NORMAL].xfontprefix =
c->fonts[0][GLC_STYLE_NORMAL].xfontsuffix = strdup("");
c->fonts[0][GLC_STYLE_NORMAL].isFont = TRUE;
glXUseXFont(c->fonts[0][GLC_STYLE_NORMAL].xfont, 0, 256, c->list_base);
for(i = 1; i < NUM_GLC_STYLES; i++) c->fonts[0][i].isFont = FALSE;
return j;
}
cl_context QHoneycombWidget::CreateContext()
{
cl_int errNum;
cl_uint numPlatforms;
cl_platform_id firstPlatformId;
cl_context context = NULL;
// First, select an OpenCL platform to run on. For this example, we
// simply choose the first available platform. Normally, you would
// query for all available platforms and select the most appropriate one.
errNum = clGetPlatformIDs(1, &firstPlatformId, &numPlatforms);
if (errNum != CL_SUCCESS || numPlatforms <= 0)
{
std::cerr << "Failed to find any OpenCL platforms." << std::endl;
return NULL;
}
// Next, create an OpenCL context on the platform. Attempt to
// create a GPU-based context, and if that fails, try to create
// a CPU-based context.
cl_context_properties contextProperties[] =
{
#ifdef _WIN32
CL_CONTEXT_PLATFORM,
(cl_context_properties)firstPlatformId,
CL_GL_CONTEXT_KHR,
(cl_context_properties)wglGetCurrentContext(),
CL_WGL_HDC_KHR,
(cl_context_properties)wglGetCurrentDC(),
#elif defined( __GNUC__)
CL_CONTEXT_PLATFORM, (cl_context_properties)clSelectedPlatformID,
CL_GL_CONTEXT_KHR, (cl_context_properties)glXGetCurrentContext(),
CL_GLX_DISPLAY_KHR, (cl_context_properties)glXGetCurrentDisplay(),
#elif defined(__APPLE__)
//todo
#endif
0
};
context = clCreateContextFromType(contextProperties, CL_DEVICE_TYPE_GPU,
NULL, NULL, &errNum);
if (errNum != CL_SUCCESS)
{
std::cout << "Could not create GPU context, trying CPU..." << std::endl;
context = clCreateContextFromType(contextProperties, CL_DEVICE_TYPE_CPU,
NULL, NULL, &errNum);
if (errNum != CL_SUCCESS)
{
std::cerr << "Failed to create an OpenCL GPU or CPU context." << std::endl;
return NULL;
}
}
return context;
}
/** Initialise GPGPU engine.
*/
void GLEngine::initialise()
{
/// Initialize GL extension wrangler
mDisplay = glXGetCurrentDisplay();
if(mDisplay == 0)
{
/// If there is none, create one
mDisplay = XOpenDisplay(NULL);
if(!mDisplay)
GPGPU_EXCEPT(ERR_RENDERSYSTEM, "Could not open X display");
}
mPBuffers.resize(PT_COUNT);
/// Initialize PBuffer for BYTE format
getPBuffer(PT_BYTE, 256, 256)->makeCurrent();
/// Initialize GL here (load extensions etc)
glewInit();
/// Get card model
std::string vendor(reinterpret_cast<const char*>(glGetString(GL_VENDOR)));
std::string renderer(reinterpret_cast<const char*>(glGetString(GL_RENDERER)));
mHWInfo.model = vendor + " " + renderer;
/// Get number of texture units
GLint maxTextureUnits;
glGetIntegerv(GL_MAX_TEXTURE_UNITS_ARB, &maxTextureUnits);
mMaxTextureUnits = (size_t)maxTextureUnits;
if(mMaxTextureUnits > GPGPU_TEXUNITS)
mMaxTextureUnits = GPGPU_TEXUNITS;
mHWInfo.textureUnits = mMaxTextureUnits;
// Check for NV or ATI float textures
if(GLEW_ATI_texture_float)
{
mFloatTexType = FTT_ATI;
mHWInfo.mFloatTextures = true;
mHWInfo.mFullFloatTextures = true;
}
else if(GLEW_NV_float_buffer)
{
mFloatTexType = FTT_NV;
mHWInfo.mFloatTextures = true;
mHWInfo.mFullFloatTextures = false;
}
/// Register program factories
mProgramFactories["Cg"] = ProgramFactoryPtr(new CgProgramFactory());
if(GLEW_ARB_shader_objects)
mProgramFactories["GLSL"] = ProgramFactoryPtr(new GLSLProgramFactory());
// Initialize program managers
for(ProgramFactoryMap::iterator i=mProgramFactories.begin(); i!=mProgramFactories.end(); ++i)
{
mHWInfo.languages.push_back(i->first);
i->second->initialise(mHWInfo);
}
}
bool Context::createContext(bool glInterop)
{
if(_initialized)
return false;
QMutexLocker locker(&_lock);
_glInterop= glInterop;
QVector<cl_context_properties> props;
if(_glInterop) {
// Add OpenGL properties
#ifdef __MACOSX
// Apple (untested)
props << CL_CGL_SHAREGROUP_KHR;
props << reinterpret_cast<cl_context_properties>(CGLGetShareGroup(CGLGetCurrentContext()));
props << CL_CONTEXT_PLATFORM;
props << reinterpret_cast<cl_context_properties>(devMgr().platform());
#elif _WIN32
// Windows (untested)
props << CL_GL_CONTEXT_KHR
props << reinterpret_cast<cl_context_properties>(wglGetCurrentContext());
props << CL_WGL_HDC_KHR
props << reinterpret_cast<cl_context_properties>(wglGetCurrentDC());
#else
// Linux/GLX
props << CL_GL_CONTEXT_KHR;
props << (cl_context_properties)glXGetCurrentContext();
props << CL_GLX_DISPLAY_KHR;
props << (cl_context_properties)glXGetCurrentDisplay();
props << (cl_context_properties)(devMgr().platform());
#endif
props << 0; // Can't use nullptr here
}
// Create OpenCL context
cl_int err;
const auto propsPtr= props.count() ? props.data() : nullptr;
const auto devs= devMgr().devices(); // Get selected devices from the dev manager
_context= clCreateContext(propsPtr, devs.count(), devs.data(), nullptr, nullptr, &err);
if(checkCLError(err, "clCreateContext"))
return false;
// Get list of supported formats
cl_uint formatCount;
err= clGetSupportedImageFormats(_context, CL_MEM_READ_WRITE, CL_MEM_OBJECT_IMAGE2D,
0, nullptr, &formatCount);
if(checkCLError(err, "clGetSupportedImageFormats") or formatCount<=0)
return false;
_imgFormats.resize(formatCount);
err= clGetSupportedImageFormats(_context, CL_MEM_READ_WRITE, CL_MEM_OBJECT_IMAGE2D,
formatCount, _imgFormats.data(), nullptr);
if(checkCLError(err, "clGetSupportedImageFormats"))
return false;
return true;
}
int main(int argc, char** argv){
glutInit(&argc, argv);
#if defined(OS_MAC)
{
char* p = strrchr(argv[0], '/');
*p = 0;
chdir(argv[0]);
//puts(getcwd(NULL, 0));
}
#endif
#if defined(OS_WIN)
OutputDebugString(TEXT("Boot up!\n"));
#endif
glutInitWindowPosition(0, 0);
glutInitWindowSize(1280, 720);
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
#if defined(OS_WIN)
glutCreateWindow_ATEXIT_HACK("ICG SSAO");
#else
glutCreateWindow("ICG SSAO");
#endif
glutDisplayFunc(onDisplay);
glutIdleFunc(onIdle);
glutReshapeFunc(onReshape);
glutKeyboardFunc(onKeyDown);
glutSpecialFunc(onSpecialDown);
glutMotionFunc(onMouseMotion);
glutPassiveMotionFunc(onMousePassiveMotion);
glewInit();
/* ENABLE V-SYNC */
int vsync = 1;
#if defined(OS_MAC)
CGLSetParameter(CGLGetCurrentContext(), kCGLCPSwapInterval, &vsync);
#elif defined(OS_WIN)
if(WGLEW_EXT_swap_control)
wglSwapIntervalEXT(vsync);
#else
if(GLXEW_EXT_swap_control)
glXSwapIntervalEXT(glXGetCurrentDisplay(), glXGetCurrentDrawable(), vsync);
#endif
onInitialization();
#if !defined(__MINGW32__)
atexit(onShutdown);
#endif
/* NO RETURN */
glutMainLoop();
return 0;
}
Bool PUBLIC
glXSet3DfxModeMESA(int mode)
{
struct _glxapi_table *t;
Display *dpy = glXGetCurrentDisplay();
GET_DISPATCH(dpy, t);
if (!t)
return False;
return (t->Set3DfxModeMESA)(mode);
}
void PUBLIC
glXFreeMemoryNV( GLvoid *pointer )
{
struct _glxapi_table *t;
Display *dpy = glXGetCurrentDisplay();
GET_DISPATCH(dpy, t);
if (!t)
return;
(t->FreeMemoryNV)(pointer);
}
GLuint PUBLIC
glXGetAGPOffsetMESA( const GLvoid *pointer )
{
struct _glxapi_table *t;
Display *dpy = glXGetCurrentDisplay();
GET_DISPATCH(dpy, t);
if (!t)
return ~0;
return (t->GetAGPOffsetMESA)(pointer);
}
void PUBLIC
glXUseXFont(Font font, int first, int count, int listBase)
{
struct _glxapi_table *t;
Display *dpy = glXGetCurrentDisplay();
GET_DISPATCH(dpy, t);
if (!t)
return;
(t->UseXFont)(font, first, count, listBase);
}
void PUBLIC
glXWaitX(void)
{
struct _glxapi_table *t;
Display *dpy = glXGetCurrentDisplay();
GET_DISPATCH(dpy, t);
if (!t)
return;
(t->WaitX)();
}
int PUBLIC
glXWaitVideoSyncSGI(int divisor, int remainder, unsigned int *count)
{
struct _glxapi_table *t;
Display *dpy = glXGetCurrentDisplay();
GET_DISPATCH(dpy, t);
if (!t || !glXGetCurrentContext())
return GLX_BAD_CONTEXT;
return (t->WaitVideoSyncSGI)(divisor, remainder, count);
}
int PUBLIC
glXGetVideoSyncSGI(unsigned int *count)
{
struct _glxapi_table *t;
Display *dpy = glXGetCurrentDisplay();
GET_DISPATCH(dpy, t);
if (!t || !glXGetCurrentContext())
return GLX_BAD_CONTEXT;
return (t->GetVideoSyncSGI)(count);
}
int PUBLIC
glXSwapIntervalSGI(int interval)
{
struct _glxapi_table *t;
Display *dpy = glXGetCurrentDisplay();
GET_DISPATCH(dpy, t);
if (!t)
return 0;
return (t->SwapIntervalSGI)(interval);
}