kc3-lang/angle/src/libEGL/libEGL.cpp

• Show log

  Commit

• Hash : fc1a44a1
  Author :
  Date : 2015-12-02T12:37:10
  

  Revert "Revert "Add and implement EGL_ANGLE_device_creation[_d3d11]""
  
  This reverts commit dd5c5b79333fdde7858a77d39e91cc3d30b74c9e.
  
  BUG=angleproject:1190
  
  Change-Id: I1bc1b232b6a916da6d18b546baf20e0854a2768f
  Reviewed-on: https://chromium-review.googlesource.com/315169
  Tested-by: Austin Kinross <aukinros@microsoft.com>
  Reviewed-by: Jamie Madill <jmadill@chromium.org>
  

Download

• src/libEGL/libEGL.cpp

• //
  // Copyright (c) 2002-2014 The ANGLE Project Authors. All rights reserved.
  // Use of this source code is governed by a BSD-style license that can be
  // found in the LICENSE file.
  //
  
  // libEGL.cpp: Implements the exported EGL functions.
  
  #include "libGLESv2/entry_points_egl.h"
  #include "libGLESv2/entry_points_egl_ext.h"
  
  extern "C"
  {
  
  EGLBoolean EGLAPIENTRY eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config)
  {
      return egl::ChooseConfig(dpy, attrib_list, configs, config_size, num_config);
  }
  
  EGLBoolean EGLAPIENTRY eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target)
  {
      return egl::CopyBuffers(dpy, surface, target);
  }
  
  EGLContext EGLAPIENTRY eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list)
  {
      return egl::CreateContext(dpy, config, share_context, attrib_list);
  }
  
  EGLSurface EGLAPIENTRY eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list)
  {
      return egl::CreatePbufferSurface(dpy, config, attrib_list);
  }
  
  EGLSurface EGLAPIENTRY eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list)
  {
      return egl::CreatePixmapSurface(dpy, config, pixmap, attrib_list);
  }
  
  EGLSurface EGLAPIENTRY eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint *attrib_list)
  {
      return egl::CreateWindowSurface(dpy, config, win, attrib_list);
  }
  
  EGLBoolean EGLAPIENTRY eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
  {
      return egl::DestroyContext(dpy, ctx);
  }
  
  EGLBoolean EGLAPIENTRY eglDestroySurface(EGLDisplay dpy, EGLSurface surface)
  {
      return egl::DestroySurface(dpy, surface);
  }
  
  EGLBoolean EGLAPIENTRY eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value)
  {
      return egl::GetConfigAttrib(dpy, config, attribute, value);
  }
  
  EGLBoolean EGLAPIENTRY eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config)
  {
      return egl::GetConfigs(dpy, configs, config_size, num_config);
  }
  
  EGLDisplay EGLAPIENTRY eglGetCurrentDisplay(void)
  {
      return egl::GetCurrentDisplay();
  }
  
  EGLSurface EGLAPIENTRY eglGetCurrentSurface(EGLint readdraw)
  {
      return egl::GetCurrentSurface(readdraw);
  }
  
  EGLDisplay EGLAPIENTRY eglGetDisplay(EGLNativeDisplayType display_id)
  {
      return egl::GetDisplay(display_id);
  }
  
  EGLint EGLAPIENTRY eglGetError(void)
  {
      return egl::GetError();
  }
  
  EGLBoolean EGLAPIENTRY eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor)
  {
      return egl::Initialize(dpy, major, minor);
  }
  
  EGLBoolean EGLAPIENTRY eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx)
  {
      return egl::MakeCurrent(dpy, draw, read, ctx);
  }
  
  EGLBoolean EGLAPIENTRY eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value)
  {
      return egl::QueryContext(dpy, ctx, attribute, value);
  }
  
  const char* EGLAPIENTRY eglQueryString(EGLDisplay dpy, EGLint name)
  {
      return egl::QueryString(dpy, name);
  }
  
  EGLBoolean EGLAPIENTRY eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value)
  {
      return egl::QuerySurface(dpy, surface, attribute, value);
  }
  
  EGLBoolean EGLAPIENTRY eglSwapBuffers(EGLDisplay dpy, EGLSurface surface)
  {
      return egl::SwapBuffers(dpy, surface);
  }
  
  EGLBoolean EGLAPIENTRY eglTerminate(EGLDisplay dpy)
  {
      return egl::Terminate(dpy);
  }
  
  EGLBoolean EGLAPIENTRY eglWaitGL(void)
  {
      return egl::WaitGL();
  }
  
  EGLBoolean EGLAPIENTRY eglWaitNative(EGLint engine)
  {
      return egl::WaitNative(engine);
  }
  
  EGLBoolean EGLAPIENTRY eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
  {
      return egl::BindTexImage(dpy, surface, buffer);
  }
  
  EGLBoolean EGLAPIENTRY eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer)
  {
      return egl::ReleaseTexImage(dpy, surface, buffer);
  }
  
  EGLBoolean EGLAPIENTRY eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value)
  {
      return egl::SurfaceAttrib(dpy, surface, attribute, value);
  }
  
  EGLBoolean EGLAPIENTRY eglSwapInterval(EGLDisplay dpy, EGLint interval)
  {
      return egl::SwapInterval(dpy, interval);
  }
  
  EGLBoolean EGLAPIENTRY eglBindAPI(EGLenum api)
  {
      return egl::BindAPI(api);
  }
  
  EGLenum EGLAPIENTRY eglQueryAPI(void)
  {
      return egl::QueryAPI();
  }
  
  EGLSurface EGLAPIENTRY eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list)
  {
      return egl::CreatePbufferFromClientBuffer(dpy, buftype, buffer, config, attrib_list);
  }
  
  EGLBoolean EGLAPIENTRY eglReleaseThread(void)
  {
      return egl::ReleaseThread();
  }
  
  EGLBoolean EGLAPIENTRY eglWaitClient(void)
  {
      return egl::WaitClient();
  }
  
  EGLContext EGLAPIENTRY eglGetCurrentContext(void)
  {
      return egl::GetCurrentContext();
  }
  
  EGLSync EGLAPIENTRY eglCreateSync(EGLDisplay dpy, EGLenum type, const EGLAttrib *attrib_list)
  {
      return egl::CreateSync(dpy, type, attrib_list);
  }
  
  EGLBoolean EGLAPIENTRY eglDestroySync(EGLDisplay dpy, EGLSync sync)
  {
      return egl::DestroySync(dpy, sync);
  }
  
  EGLint EGLAPIENTRY eglClientWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags, EGLTime timeout)
  {
      return egl::ClientWaitSync(dpy, sync, flags, timeout);
  }
  
  EGLBoolean EGLAPIENTRY eglGetSyncAttrib(EGLDisplay dpy, EGLSync sync, EGLint attribute, EGLAttrib *value)
  {
      return egl::GetSyncAttrib(dpy, sync, attribute, value);
  }
  
  EGLImage EGLAPIENTRY eglCreateImage(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLAttrib *attrib_list)
  {
      return egl::CreateImage(dpy, ctx, target, buffer, attrib_list);
  }
  
  EGLBoolean EGLAPIENTRY eglDestroyImage(EGLDisplay dpy, EGLImage image)
  {
      return egl::DestroyImage(dpy, image);
  }
  
  EGLDisplay EGLAPIENTRY eglGetPlatformDisplay(EGLenum platform, void *native_display, const EGLAttrib *attrib_list)
  {
      return egl::GetPlatformDisplay(platform, native_display, attrib_list);
  }
  
  EGLSurface EGLAPIENTRY eglCreatePlatformWindowSurface(EGLDisplay dpy, EGLConfig config, void *native_window, const EGLAttrib *attrib_list)
  {
      return egl::CreatePlatformWindowSurface(dpy, config, native_window, attrib_list);
  }
  
  EGLSurface EGLAPIENTRY eglCreatePlatformPixmapSurface(EGLDisplay dpy, EGLConfig config, void *native_pixmap, const EGLAttrib *attrib_list)
  {
      return egl::CreatePlatformPixmapSurface(dpy, config, native_pixmap, attrib_list);
  }
  
  EGLBoolean EGLAPIENTRY eglWaitSync(EGLDisplay dpy, EGLSync sync, EGLint flags)
  {
      return egl::WaitSync(dpy, sync, flags);
  }
  
  EGLBoolean EGLAPIENTRY eglQuerySurfacePointerANGLE(EGLDisplay dpy, EGLSurface surface, EGLint attribute, void **value)
  {
      return egl::QuerySurfacePointerANGLE(dpy, surface, attribute, value);
  }
  
  EGLBoolean EGLAPIENTRY eglPostSubBufferNV(EGLDisplay dpy, EGLSurface surface, EGLint x, EGLint y, EGLint width, EGLint height)
  {
      return egl::PostSubBufferNV(dpy, surface, x, y, width, height);
  }
  
  EGLDisplay EGLAPIENTRY eglGetPlatformDisplayEXT(EGLenum platform, void *native_display, const EGLint *attrib_list)
  {
      return egl::GetPlatformDisplayEXT(platform, native_display, attrib_list);
  }
  
  EGLBoolean EGLAPIENTRY eglQueryDisplayAttribEXT(EGLDisplay dpy, EGLint attribute, EGLAttrib *value)
  {
      return egl::QueryDisplayAttribEXT(dpy, attribute, value);
  }
  
  EGLBoolean EGLAPIENTRY eglQueryDeviceAttribEXT(EGLDeviceEXT device, EGLint attribute, EGLAttrib *value)
  {
      return egl::QueryDeviceAttribEXT(device, attribute, value);
  }
  
  const char * EGLAPIENTRY eglQueryDeviceStringEXT(EGLDeviceEXT device, EGLint name)
  {
      return egl::QueryDeviceStringEXT(device, name);
  }
  
  EGLImageKHR EGLAPIENTRY eglCreateImageKHR(EGLDisplay dpy,
                                            EGLContext ctx,
                                            EGLenum target,
                                            EGLClientBuffer buffer,
                                            const EGLint *attrib_list)
  {
      return egl::CreateImageKHR(dpy, ctx, target, buffer, attrib_list);
  }
  
  EGLBoolean EGLAPIENTRY eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image)
  {
      return egl::DestroyImageKHR(dpy, image);
  }
  
  EGLDeviceEXT EGLAPIENTRY eglCreateDeviceANGLE(EGLint device_type,
                                                void *native_device,
                                                const EGLAttrib *attrib_list)
  {
      return egl::CreateDeviceANGLE(device_type, native_device, attrib_list);
  }
  
  EGLBoolean EGLAPIENTRY eglReleaseDeviceANGLE(EGLDeviceEXT device)
  {
      return egl::ReleaseDeviceANGLE(device);
  }
  
  __eglMustCastToProperFunctionPointerType EGLAPIENTRY eglGetProcAddress(const char *procname)
  {
      return egl::GetProcAddress(procname);
  }
  
  }
  

Download