OpenGL OpenCL sample

057cd52 first versions: cv::ogl::convertFromGLTexture2D & cv::ogl::convertToGLTexture2D
5656e94 added autogenerated stuff for cl_gl.h
765f1fd resolved CL functions in opengl.cpp
9f9fee3 implemented function cv::ogl::ocl::initializeContextFromGLTexture2D()
a792adb cv::ogl::ocl::initializeContextFromGLTexture2D() - added linux support (glx.h)
51c2869 added missing error message in function cv::ogl::ocl::initializeContextFromGLTexture2D()
513b887 fixed extension call in function cv::ogl::ocl::initializeContextFromGLTexture2D()
475a3e9 added CL-GL interop Windows sample (gpu/opengl_interop.cpp)
07af28f added building of CL-GL interop sample - Windows only
befe3a2 fixed whitespace errors & doxygen warnings (precommit_docs)
551251a changed function name to cv::ogl::ocl::initializeContextFromGL(), removed unused argument
4d5f009 changed CL_DEVICES_FOR_GL_CONTEXT_KHR to CL_CURRENT_DEVICE_FOR_GL_CONTEXT_KHR
9fc3055 changed CL_DEVICES_FOR_GL_CONTEXT_KHR to CL_CURRENT_DEVICE_FOR_GL_CONTEXT_KH
6d31cee Revert "changed CL_DEVICES_FOR_GL_CONTEXT_KHR to CL_CURRENT_DEVICE_FOR_GL_CONTEXT_KH"
cc6a025 added texture format check in cv::ogl::convertFromGLTexture2D()
063a2c1 CL-GL sample: added Linux implementation (Xlib/GLX)
c392ae9 fixed trailing whitespace
85a80d0 fixed include files
ae23628 excluded samples/opengl from build case 2
9870ea5 added android EGL support
530b64c added doxygen documentation comments to CL-GL interop functions

modules/core/include/opencv2/core/opengl.hpp

@@ -48,6 +48,7 @@
 #endif
 
 #include "opencv2/core.hpp"
+#include "ocl.hpp"
 
 namespace cv { namespace ogl {
 
@@ -511,7 +512,30 @@ CV_EXPORTS void render(const Arrays& arr, int mode = POINTS, Scalar color = Scal
 */
 CV_EXPORTS void render(const Arrays& arr, InputArray indices, int mode = POINTS, Scalar color = Scalar::all(255));
 
-//! @} core_opengl
+/////////////////// CL-GL Interoperability Functions ///////////////////
+
+namespace ocl {
+using namespace cv::ocl;
+
+// TODO static functions in the Context class
+/** @brief Creates OpenCL context from GL.
+@return Returns reference to OpenCL Context
+ */
+CV_EXPORTS Context& initializeContextFromGL();
+
+} // namespace cv::ogl::ocl
+
+/** @brief Converts InputArray to Texture2D object.
+@param src     - source InputArray.
+@param texture - destination Texture2D object.
+ */
+CV_EXPORTS void convertToGLTexture2D(InputArray src, Texture2D& texture);
+
+/** @brief Converts Texture2D object to OutputArray.
+@param texture - source Texture2D object.
+@param dst     - destination OutputArray.
+ */
+CV_EXPORTS void convertFromGLTexture2D(const Texture2D& texture, OutputArray dst);
 
 }} // namespace cv::ogl
 

modules/core/src/opengl.cpp

@@ -47,7 +47,9 @@
 #  ifdef HAVE_CUDA
 #    include <cuda_gl_interop.h>
 #  endif
-#endif
+#else // HAVE_OPENGL
+#  define NO_OPENGL_SUPPORT_ERROR CV_ErrorNoReturn(cv::Error::StsBadFunc, "OpenCV was build without OpenGL support")
+#endif // HAVE_OPENGL
 
 using namespace cv;
 using namespace cv::cuda;
@@ -1572,3 +1574,264 @@ void cv::ogl::render(const ogl::Arrays& arr, InputArray indices, int mode, Scala
     }
 #endif
 }
+
+////////////////////////////////////////////////////////////////////////
+// CL-GL Interoperability
+
+#ifdef HAVE_OPENCL
+#  include "opencv2/core/opencl/runtime/opencl_gl.hpp"
+#else // HAVE_OPENCL
+#  define NO_OPENCL_SUPPORT_ERROR CV_ErrorNoReturn(cv::Error::StsBadFunc, "OpenCV was build without OpenCL support")
+#endif // HAVE_OPENCL
+
+#if defined(HAVE_OPENGL)
+#  if defined(ANDROID)
+#    include <EGL/egl.h>
+#  elif defined(__linux__)
+#    include <GL/glx.h>
+#  endif
+#endif // HAVE_OPENGL
+
+namespace cv { namespace ogl {
+
+namespace ocl {
+
+Context& initializeContextFromGL()
+{
+#if !defined(HAVE_OPENGL)
+    NO_OPENGL_SUPPORT_ERROR;
+#elif !defined(HAVE_OPENCL)
+    NO_OPENCL_SUPPORT_ERROR;
+#else
+    cl_uint numPlatforms;
+    cl_int status = clGetPlatformIDs(0, NULL, &numPlatforms);
+    if (status != CL_SUCCESS)
+        CV_Error(cv::Error::OpenCLInitError, "OpenCL: Can't get number of platforms");
+    if (numPlatforms == 0)
+        CV_Error(cv::Error::OpenCLInitError, "OpenCL: No available platforms");
+
+    std::vector<cl_platform_id> platforms(numPlatforms);
+    status = clGetPlatformIDs(numPlatforms, &platforms[0], NULL);
+    if (status != CL_SUCCESS)
+        CV_Error(cv::Error::OpenCLInitError, "OpenCL: Can't get number of platforms");
+
+    // TODO Filter platforms by name from OPENCV_OPENCL_DEVICE
+
+    int found = -1;
+    cl_device_id device = NULL;
+    cl_context context = NULL;
+
+    for (int i = 0; i < (int)numPlatforms; i++)
+    {
+        // query platform extension: presence of "cl_khr_gl_sharing" extension is requred
+        {
+            AutoBuffer<char> extensionStr;
+
+            size_t extensionSize;
+            status = clGetPlatformInfo(platforms[i], CL_PLATFORM_EXTENSIONS, 0, NULL, &extensionSize);
+            if (status == CL_SUCCESS)
+            {
+                extensionStr.allocate(extensionSize+1);
+                status = clGetPlatformInfo(platforms[i], CL_PLATFORM_EXTENSIONS, extensionSize, (char*)extensionStr, NULL);
+            }
+            if (status != CL_SUCCESS)
+                CV_Error(cv::Error::OpenCLInitError, "OpenCL: Can't get platform extension string");
+
+            if (!strstr((const char*)extensionStr, "cl_khr_gl_sharing"))
+                continue;
+        }
+
+        clGetGLContextInfoKHR_fn clGetGLContextInfoKHR = (clGetGLContextInfoKHR_fn)
+                clGetExtensionFunctionAddressForPlatform(platforms[i], "clGetGLContextInfoKHR");
+        if (!clGetGLContextInfoKHR)
+            continue;
+
+        cl_context_properties properties[] =
+        {
+#if defined(WIN32) || defined(_WIN32)
+            CL_CONTEXT_PLATFORM, (cl_context_properties)platforms[i],
+            CL_GL_CONTEXT_KHR, (cl_context_properties)wglGetCurrentContext(),
+            CL_WGL_HDC_KHR, (cl_context_properties)wglGetCurrentDC(),
+#elif defined(ANDROID)
+            CL_CONTEXT_PLATFORM, (cl_context_properties)platforms[i],
+            CL_GL_CONTEXT_KHR, (cl_context_properties)eglGetCurrentContext(),
+            CL_EGL_DISPLAY_KHR, (cl_context_properties)eglGetCurrentDisplay(),
+#elif defined(__linux__)
+            CL_CONTEXT_PLATFORM, (cl_context_properties)platforms[i],
+            CL_GL_CONTEXT_KHR, (cl_context_properties)glXGetCurrentContext(),
+            CL_GLX_DISPLAY_KHR, (cl_context_properties)glXGetCurrentDisplay(),
+#endif
+            0
+        };
+
+        // query device
+        device = NULL;
+        size_t numDevices = 0;
+        {
+            size_t sizeDevices = 0;
+            status = clGetGLContextInfoKHR(properties, CL_CURRENT_DEVICE_FOR_GL_CONTEXT_KHR, 0, NULL, &sizeDevices);
+            if (status == CL_SUCCESS)
+            {
+                numDevices = sizeDevices / sizeof(cl_device_id);
+                if (numDevices > 0)
+                {
+                    numDevices = 1;
+                    sizeDevices = numDevices * sizeof(cl_device_id);
+                    status = clGetGLContextInfoKHR(properties, CL_CURRENT_DEVICE_FOR_GL_CONTEXT_KHR, sizeDevices, (void*)&device, NULL);
+                }
+            }
+            if (status != CL_SUCCESS)
+                continue;
+        }
+
+        // create context
+        if (numDevices > 0)
+        {
+            context = clCreateContext(properties, 1, &device, NULL, NULL, &status);
+            if (status != CL_SUCCESS)
+            {
+                clReleaseDevice(device);
+            }
+            else
+            {
+                found = i;
+                break;
+            }
+        }
+    }
+
+    if (found < 0)
+        CV_Error(cv::Error::OpenCLInitError, "OpenCL: Can't create context for OpenGL interop");
+
+    Context& ctx = Context::getDefault(false);
+    initializeContextFromHandle(ctx, platforms[found], context, device);
+    return ctx;
+#endif
+}
+
+} // namespace cv::ogl::ocl
+
+#if defined(HAVE_OPENGL) && defined(HAVE_OPENCL)
+static void __OpenCLinitializeGL()
+{
+// temp stub
+}
+#endif // defined(HAVE_OPENGL) && defined(HAVE_OPENCL)
+
+void convertToGLTexture2D(InputArray src, Texture2D& texture)
+{
+    (void)src; (void)texture;
+#if !defined(HAVE_OPENGL)
+    NO_OPENGL_SUPPORT_ERROR;
+#elif !defined(HAVE_OPENCL)
+    NO_OPENCL_SUPPORT_ERROR;
+#else
+    // ... // check "interop available" flag first (i.e. sharegroup existence)
+    __OpenCLinitializeGL();
+
+    Size srcSize = src.size();
+    CV_Assert(srcSize.width == (int)texture.cols() && srcSize.height == (int)texture.rows());
+
+    using namespace cv::ocl;
+    Context& ctx = Context::getDefault();
+    cl_context context = (cl_context)ctx.ptr();
+
+    UMat u = src.getUMat();
+
+    // TODO Add support for roi
+    CV_Assert(u.offset == 0);
+    CV_Assert(u.isContinuous());
+
+    cl_int status = 0;
+    cl_mem clImage = clCreateFromGLTexture(context, CL_MEM_WRITE_ONLY, gl::TEXTURE_2D, 0, texture.texId(), &status);
+    if (status != CL_SUCCESS)
+        CV_Error(cv::Error::OpenCLApiCallError, "OpenCL: clCreateFromGLTexture failed");
+
+    cl_mem clBuffer = (cl_mem)u.handle(ACCESS_READ);
+
+    cl_command_queue q = (cl_command_queue)Queue::getDefault().ptr();
+    status = clEnqueueAcquireGLObjects(q, 1, &clImage, 0, NULL, NULL);
+    if (status != CL_SUCCESS)
+        CV_Error(cv::Error::OpenCLApiCallError, "OpenCL: clEnqueueAcquireGLObjects failed");
+    size_t offset = 0; // TODO
+    size_t dst_origin[3] = {0, 0, 0};
+    size_t region[3] = {u.cols, u.rows, 1};
+    status = clEnqueueCopyBufferToImage(q, clBuffer, clImage, offset, dst_origin, region, 0, NULL, NULL);
+    if (status != CL_SUCCESS)
+        CV_Error(cv::Error::OpenCLApiCallError, "OpenCL: clEnqueueCopyBufferToImage failed");
+    status = clEnqueueReleaseGLObjects(q, 1, &clImage, 0, NULL, NULL);
+    if (status != CL_SUCCESS)
+        CV_Error(cv::Error::OpenCLApiCallError, "OpenCL: clEnqueueReleaseGLObjects failed");
+
+    status = clFinish(q); // TODO Use events
+    if (status != CL_SUCCESS)
+        CV_Error(cv::Error::OpenCLApiCallError, "OpenCL: clFinish failed");
+
+    status = clReleaseMemObject(clImage); // TODO RAII
+    if (status != CL_SUCCESS)
+        CV_Error(cv::Error::OpenCLApiCallError, "OpenCL: clReleaseMemObject failed");
+#endif
+}
+
+void convertFromGLTexture2D(const Texture2D& texture, OutputArray dst)
+{
+    (void)texture; (void)dst;
+#if !defined(HAVE_OPENGL)
+    NO_OPENGL_SUPPORT_ERROR;
+#elif !defined(HAVE_OPENCL)
+    NO_OPENCL_SUPPORT_ERROR;
+#else
+    // ... // check "interop available" flag first (i.e. sharegroup existence)
+    __OpenCLinitializeGL();
+
+    // check texture format
+    const int dtype = CV_8UC4;
+    CV_Assert(texture.format() == Texture2D::RGBA);
+
+    int textureType = dtype;
+    CV_Assert(textureType >= 0);
+
+    using namespace cv::ocl;
+    Context& ctx = Context::getDefault();
+    cl_context context = (cl_context)ctx.ptr();
+
+    // TODO Need to specify ACCESS_WRITE here somehow to prevent useless data copying!
+    dst.create(texture.size(), textureType);
+    UMat u = dst.getUMat();
+
+    // TODO Add support for roi
+    CV_Assert(u.offset == 0);
+    CV_Assert(u.isContinuous());
+
+    cl_int status = 0;
+    cl_mem clImage = clCreateFromGLTexture(context, CL_MEM_READ_ONLY, gl::TEXTURE_2D, 0, texture.texId(), &status);
+    if (status != CL_SUCCESS)
+        CV_Error(cv::Error::OpenCLApiCallError, "OpenCL: clCreateFromGLTexture failed");
+
+    cl_mem clBuffer = (cl_mem)u.handle(ACCESS_READ);
+
+    cl_command_queue q = (cl_command_queue)Queue::getDefault().ptr();
+    status = clEnqueueAcquireGLObjects(q, 1, &clImage, 0, NULL, NULL);
+    if (status != CL_SUCCESS)
+        CV_Error(cv::Error::OpenCLApiCallError, "OpenCL: clEnqueueAcquireGLObjects failed");
+    size_t offset = 0; // TODO
+    size_t src_origin[3] = {0, 0, 0};
+    size_t region[3] = {u.cols, u.rows, 1};
+    status = clEnqueueCopyImageToBuffer(q, clImage, clBuffer, src_origin, region, offset, 0, NULL, NULL);
+    if (status != CL_SUCCESS)
+        CV_Error(cv::Error::OpenCLApiCallError, "OpenCL: clEnqueueCopyImageToBuffer failed");
+    status = clEnqueueReleaseGLObjects(q, 1, &clImage, 0, NULL, NULL);
+    if (status != CL_SUCCESS)
+        CV_Error(cv::Error::OpenCLApiCallError, "OpenCL: clEnqueueReleaseGLObjects failed");
+
+    status = clFinish(q); // TODO Use events
+    if (status != CL_SUCCESS)
+        CV_Error(cv::Error::OpenCLApiCallError, "OpenCL: clFinish failed");
+
+    status = clReleaseMemObject(clImage); // TODO RAII
+    if (status != CL_SUCCESS)
+        CV_Error(cv::Error::OpenCLApiCallError, "OpenCL: clReleaseMemObject failed");
+#endif
+}
+
+}} // namespace cv::ogl

samples/CMakeLists.txt

@@ -18,6 +18,10 @@ if(WIN32 AND HAVE_DIRECTX)
   add_subdirectory(directx)
 endif()
 
+if((NOT ANDROID) AND HAVE_OPENGL)
+  add_subdirectory(opengl)
+endif()
+
 if(ANDROID AND BUILD_ANDROID_EXAMPLES)
   add_subdirectory(android)
 endif()

samples/opengl/CMakeLists.txt

+SET(OPENCV_OPENGL_SAMPLES_REQUIRED_DEPS opencv_core opencv_imgproc opencv_imgcodecs opencv_videoio opencv_highgui)
+
+ocv_check_dependencies(${OPENCV_OPENGL_SAMPLES_REQUIRED_DEPS})
+
+if(BUILD_EXAMPLES AND OCV_DEPENDENCIES_FOUND)
+  set(project "opengl")
+  string(TOUPPER "${project}" project_upper)
+
+  project("${project}_samples")
+
+  ocv_include_modules_recurse(${OPENCV_OPENGL_SAMPLES_REQUIRED_DEPS})
+
+  # ---------------------------------------------
+  #      Define executable targets
+  # ---------------------------------------------
+  MACRO(OPENCV_DEFINE_OPENGL_EXAMPLE name srcs)
+    set(the_target "example_${project}_${name}")
+    add_executable(${the_target} ${srcs})
+
+    ocv_target_link_libraries(${the_target} ${OPENCV_LINKER_LIBS} ${OPENCV_OPENGL_SAMPLES_REQUIRED_DEPS})
+
+    set_target_properties(${the_target} PROPERTIES
+      OUTPUT_NAME "${project}-example-${name}"
+      PROJECT_LABEL "(EXAMPLE_${project_upper}) ${name}")
+
+    if(ENABLE_SOLUTION_FOLDERS)
+      set_target_properties(${the_target} PROPERTIES FOLDER "samples//${project}")
+    endif()
+
+    if(WIN32)
+      if(MSVC AND NOT BUILD_SHARED_LIBS)
+        set_target_properties(${the_target} PROPERTIES LINK_FLAGS "/NODEFAULTLIB:atlthunk.lib /NODEFAULTLIB:atlsd.lib /DEBUG")
+      endif()
+      install(TARGETS ${the_target} RUNTIME DESTINATION "${OPENCV_SAMPLES_BIN_INSTALL_PATH}/${project}" COMPONENT samples)
+    endif()
+  ENDMACRO()
+
+  file(GLOB all_samples RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp)
+
+  foreach(sample_filename ${all_samples})
+    get_filename_component(sample ${sample_filename} NAME_WE)
+    file(GLOB sample_srcs RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} ${sample}.*)
+    OPENCV_DEFINE_OPENGL_EXAMPLE(${sample} ${sample_srcs})
+  endforeach()
+endif()

samples/opengl/winapp.hpp

+#if defined(WIN32) || defined(_WIN32)
+# define WIN32_LEAN_AND_MEAN
+# include <windows.h>
+#elif defined(__linux__)
+# include <X11/X.h>
+# include <X11/Xlib.h>
+# include <X11/Xutil.h>
+#endif
+
+#include <string>
+
+#include <GL/gl.h>
+#if defined(WIN32) || defined(_WIN32)
+# include <GL/glu.h>
+#elif defined(__linux__)
+# include <GL/glx.h>
+#endif
+
+#if defined(WIN32) || defined(_WIN32)
+# define WINCLASS "WinAppWnd"
+#endif
+
+#define SAFE_RELEASE(p) if (p) { p->Release(); p = NULL; }
+
+class WinApp
+{
+public:
+    WinApp(int width, int height, std::string& window_name)
+    {
+        m_width       = width;
+        m_height      = height;
+        m_window_name = window_name;
+#if defined(WIN32) || defined(_WIN32)
+        m_hInstance   = ::GetModuleHandle(NULL);
+#endif
+    }
+
+    virtual ~WinApp()
+    {
+#if defined(WIN32) || defined(_WIN32)
+        ::UnregisterClass(WINCLASS, m_hInstance);
+#endif
+    }
+
+    int create()
+    {
+#if defined(WIN32) || defined(_WIN32)
+        WNDCLASSEX wcex;
+
+        wcex.cbSize        = sizeof(WNDCLASSEX);
+        wcex.style         = CS_HREDRAW | CS_VREDRAW;
+        wcex.lpfnWndProc   = &WinApp::StaticWndProc;
+        wcex.cbClsExtra    = 0;
+        wcex.cbWndExtra    = 0;
+        wcex.hInstance     = m_hInstance;
+        wcex.hIcon         = LoadIcon(0, IDI_APPLICATION);
+        wcex.hCursor       = LoadCursor(0, IDC_ARROW);
+        wcex.hbrBackground = 0;
+        wcex.lpszMenuName  = 0L;
+        wcex.lpszClassName = WINCLASS;
+        wcex.hIconSm       = 0;
+
+        ATOM wc = ::RegisterClassEx(&wcex);
+
+        RECT rc = { 0, 0, m_width, m_height };
+        ::AdjustWindowRect(&rc, WS_OVERLAPPEDWINDOW, false);
+
+        m_hWnd = ::CreateWindow(
+                     (LPCTSTR)wc, m_window_name.c_str(),
+                     WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT,
+                     rc.right - rc.left, rc.bottom - rc.top,
+                     NULL, NULL, m_hInstance, (void*)this);
+
+        if (!m_hWnd)
+            return -1;
+
+        ::ShowWindow(m_hWnd, SW_SHOW);
+        ::UpdateWindow(m_hWnd);
+        ::SetFocus(m_hWnd);
+#elif defined(__linux__)
+        m_display = XOpenDisplay(NULL);
+
+        if (m_display == NULL)
+        {
+            return -1;
+        }
+
+        m_WM_DELETE_WINDOW = XInternAtom(m_display, "WM_DELETE_WINDOW", False);
+
+        static GLint visual_attributes[] = { GLX_RGBA, GLX_DEPTH_SIZE, 24, GLX_DOUBLEBUFFER, None };
+        m_visual_info = glXChooseVisual(m_display, 0, visual_attributes);
+
+        if (m_visual_info == NULL)
+        {
+            XCloseDisplay(m_display);
+            return -2;
+        }
+
+        Window root = DefaultRootWindow(m_display);
+
+        m_event_mask = ExposureMask | KeyPressMask;
+
+        XSetWindowAttributes window_attributes;
+        window_attributes.colormap = XCreateColormap(m_display, root, m_visual_info->visual, AllocNone);
+        window_attributes.event_mask = m_event_mask;
+
+        m_window = XCreateWindow(
+            m_display, root, 0, 0, m_width, m_height, 0, m_visual_info->depth,
+            InputOutput, m_visual_info->visual, CWColormap | CWEventMask, &window_attributes);
+
+        XMapWindow(m_display, m_window);
+        XSetWMProtocols(m_display, m_window, &m_WM_DELETE_WINDOW, 1);
+        XStoreName(m_display, m_window, m_window_name.c_str());
+#endif
+
+        return init();
+    }
+
+#if defined(WIN32) || defined(_WIN32)
+    virtual LRESULT CALLBACK WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam) = 0;
+#endif
+
+    int run()
+    {
+#if defined(WIN32) || defined(_WIN32)
+        MSG msg;
+
+        ::ZeroMemory(&msg, sizeof(msg));
+
+        while (msg.message != WM_QUIT)
+        {
+            if (::PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE))
+            {
+                ::TranslateMessage(&msg);
+                ::DispatchMessage(&msg);
+            }
+            else
+            {
+                idle();
+            }
+        }
+
+        return static_cast<int>(msg.wParam);
+#elif defined(__linux__)
+        m_end_loop = false;
+
+        do {
+            XEvent e;
+
+            if (!XCheckWindowEvent(m_display, m_window, m_event_mask, &e) || !handle_event(e))
+            {
+                idle();
+            }
+        } while (!m_end_loop);
+#endif
+
+        return 0;
+    }
+
+protected:
+
+#if defined(WIN32) || defined(_WIN32)
+    static LRESULT CALLBACK StaticWndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
+    {
+        WinApp* pWnd;
+
+        if (message == WM_NCCREATE)
+        {
+            LPCREATESTRUCT pCreateStruct = ((LPCREATESTRUCT)lParam);
+            pWnd = (WinApp*)(pCreateStruct->lpCreateParams);
+            ::SetWindowLongPtr(hWnd, GWLP_USERDATA, (LONG_PTR)pWnd);
+        }
+
+        pWnd = GetObjectFromWindow(hWnd);
+
+        if (pWnd)
+            return pWnd->WndProc(hWnd, message, wParam, lParam);
+        else
+            return ::DefWindowProc(hWnd, message, wParam, lParam);
+    }
+
+    inline static WinApp* GetObjectFromWindow(HWND hWnd)
+    {
+        return (WinApp*)::GetWindowLongPtr(hWnd, GWLP_USERDATA);
+    }
+#endif
+
+#if defined(__linux__)
+    virtual int handle_event(XEvent& e) = 0;
+#endif
+
+    virtual int init() = 0;
+    virtual int render() = 0;
+
+    virtual void idle() = 0;
+
+#if defined(WIN32) || defined(_WIN32)
+    HINSTANCE    m_hInstance;
+    HWND         m_hWnd;
+#elif defined(__linux__)
+    Display*     m_display;
+    XVisualInfo* m_visual_info;
+    Window       m_window;
+    long         m_event_mask;
+    Atom         m_WM_DELETE_WINDOW;
+    bool         m_end_loop;
+#endif
+    int          m_width;
+    int          m_height;
+    std::string  m_window_name;
+};