예제 #1
0
gfx_ctx_proc_t egl_get_proc_address(const char *symbol)
{
   gfx_ctx_proc_t ret;
   void *sym__ = NULL;

   retro_assert(sizeof(void*) == sizeof(void (*)(void)));

   sym__ = (void*)eglGetProcAddress(symbol);
   memcpy(&ret, &sym__, sizeof(void*));

   return ret;
}
예제 #2
0
static GrGLFuncPtr angle_get_gl_proc(void* ctx, const char name[]) {
    const ANGLEAssembleContext& context = *reinterpret_cast<const ANGLEAssembleContext*>(ctx);
    GrGLFuncPtr proc = (GrGLFuncPtr) GetProcAddress(context.fGL, name);
    if (proc) {
        return proc;
    }
    proc = (GrGLFuncPtr) GetProcAddress(context.fEGL, name);
    if (proc) {
        return proc;
    }
    return eglGetProcAddress(name);
}
QFunctionPointer QQnxGLContext::getProcAddress(const QByteArray &procName)
{
    qGLContextDebug() << Q_FUNC_INFO;

    // Set current rendering API
    EGLBoolean eglResult = eglBindAPI(EGL_OPENGL_ES_API);
    if (eglResult != EGL_TRUE)
        qFatal("QQNX: failed to set EGL API, err=%d", eglGetError());

    // Lookup EGL extension function pointer
    return static_cast<QFunctionPointer>(eglGetProcAddress(procName.constData()));
}
static GrGLFuncPtr angle_get_gl_proc(void* ctx, const char name[]) {
    const Libs* libs = reinterpret_cast<const Libs*>(ctx);
    GrGLFuncPtr proc = (GrGLFuncPtr) GetProcedureAddress(libs->fGLLib, name);
    if (proc) {
        return proc;
    }
    proc = (GrGLFuncPtr) GetProcedureAddress(libs->fEGLLib, name);
    if (proc) {
        return proc;
    }
    return eglGetProcAddress(name);
}
예제 #5
0
static gfx_ctx_proc_t gfx_ctx_qnx_get_proc_address(const char *symbol)
{
   gfx_ctx_proc_t ret;
   void *sym__;

   rarch_assert(sizeof(void*) == sizeof(void (*)(void)));

   sym__ = eglGetProcAddress(symbol);
   memcpy(&ret, &sym__, sizeof(void*));

   return ret;
}
예제 #6
0
bool Extensions3DOpenGLES::supportsExtension(const String& name)
{
    if (m_availableExtensions.contains(name)) {
        if (!m_supportsOESvertexArrayObject && name == "GL_OES_vertex_array_object") {
            m_glBindVertexArrayOES = reinterpret_cast<PFNGLBINDVERTEXARRAYOESPROC>(eglGetProcAddress("glBindVertexArrayOES"));
            m_glGenVertexArraysOES = reinterpret_cast<PFNGLGENVERTEXARRAYSOESPROC>(eglGetProcAddress("glGenVertexArraysOES"));
            m_glDeleteVertexArraysOES = reinterpret_cast<PFNGLDELETEVERTEXARRAYSOESPROC>(eglGetProcAddress("glDeleteVertexArraysOES"));
            m_glIsVertexArrayOES = reinterpret_cast<PFNGLISVERTEXARRAYOESPROC>(eglGetProcAddress("glIsVertexArrayOES"));
            m_supportsOESvertexArrayObject = true;
        } else if (!m_supportsIMGMultisampledRenderToTexture && name == "GL_IMG_multisampled_render_to_texture") {
            m_glFramebufferTexture2DMultisampleIMG = reinterpret_cast<PFNGLFRAMEBUFFERTEXTURE2DMULTISAMPLEIMG>(eglGetProcAddress("glFramebufferTexture2DMultisampleIMG"));
            m_glRenderbufferStorageMultisampleIMG = reinterpret_cast<PFNGLRENDERBUFFERSTORAGEMULTISAMPLEIMG>(eglGetProcAddress("glRenderbufferStorageMultisampleIMG"));
            m_supportsIMGMultisampledRenderToTexture = true;
        } else if (!m_glGetGraphicsResetStatusEXT && name == "GL_EXT_robustness") {
            m_glGetGraphicsResetStatusEXT = reinterpret_cast<PFNGLGETGRAPHICSRESETSTATUSEXTPROC>(eglGetProcAddress("glGetGraphicsResetStatusEXT"));
            m_glReadnPixelsEXT = reinterpret_cast<PFNGLREADNPIXELSEXTPROC>(eglGetProcAddress("glReadnPixelsEXT"));
            m_glGetnUniformfvEXT = reinterpret_cast<PFNGLGETNUNIFORMFVEXTPROC>(eglGetProcAddress("glGetnUniformfvEXT"));
            m_glGetnUniformivEXT = reinterpret_cast<PFNGLGETNUNIFORMIVEXTPROC>(eglGetProcAddress("glGetnUniformivEXT"));
        } else if (!m_supportsANGLEinstancedArrays && name == "GL_ANGLE_instanced_arrays") {
            m_glVertexAttribDivisorANGLE = reinterpret_cast<PFNGLVERTEXATTRIBDIVISORANGLEPROC>(eglGetProcAddress("glVertexAttribDivisorANGLE"));
            m_glDrawArraysInstancedANGLE = reinterpret_cast<PFNGLDRAWARRAYSINSTANCEDANGLEPROC >(eglGetProcAddress("glDrawArraysInstancedANGLE"));
            m_glDrawElementsInstancedANGLE = reinterpret_cast<PFNGLDRAWELEMENTSINSTANCEDANGLEPROC >(eglGetProcAddress("glDrawElementsInstancedANGLE"));
            m_supportsANGLEinstancedArrays = true;
        } else if (name == "GL_EXT_draw_buffers") {
            // FIXME: implement the support.
            return false;
        }
        return true;
    }

    return false;
}
예제 #7
0
void glResolveFunctions(OpenGLPlatformInterface platformInterface)
{
    const bool haveArbRobustness = hasGLExtension(QByteArrayLiteral("GL_ARB_robustness"));
    const bool haveExtRobustness = hasGLExtension(QByteArrayLiteral("GL_EXT_robustness"));
    bool robustContext = false;
    if (GLPlatform::instance()->isGLES()) {
        if (haveExtRobustness) {
            GLint value = 0;
            glGetIntegerv(GL_CONTEXT_ROBUST_ACCESS_EXT, &value);
            robustContext = (value != 0);
        }
    } else {
        if (haveArbRobustness) {
            if (hasGLVersion(3, 0)) {
                GLint value = 0;
                glGetIntegerv(GL_CONTEXT_FLAGS, &value);
                if (value & GL_CONTEXT_FLAG_ROBUST_ACCESS_BIT_ARB) {
                    robustContext = true;
                }
            } else {
                robustContext = true;
            }
        }
    }
    if (robustContext && haveArbRobustness) {
        // See http://www.opengl.org/registry/specs/ARB/robustness.txt
        GL_RESOLVE_WITH_EXT(glGetGraphicsResetStatus, glGetGraphicsResetStatusARB);
        GL_RESOLVE_WITH_EXT(glReadnPixels,            glReadnPixelsARB);
        GL_RESOLVE_WITH_EXT(glGetnUniformfv,          glGetnUniformfvARB);
    } else if (robustContext && haveExtRobustness) {
        // See http://www.khronos.org/registry/gles/extensions/EXT/EXT_robustness.txt
        glGetGraphicsResetStatus = (glGetGraphicsResetStatus_func) eglGetProcAddress("glGetGraphicsResetStatusEXT");
        glReadnPixels            = (glReadnPixels_func)            eglGetProcAddress("glReadnPixelsEXT");
        glGetnUniformfv          = (glGetnUniformfv_func)          eglGetProcAddress("glGetnUniformfvEXT");
    } else {
        glGetGraphicsResetStatus = KWin::GetGraphicsResetStatus;
        glReadnPixels            = KWin::ReadnPixels;
        glGetnUniformfv          = KWin::GetnUniformfv;
    }
}
예제 #8
0
파일: Scene.cpp 프로젝트: sunzhiyuan/opencl
//--------------------------------------------------------------------------------------
// Name: CSample()
// Desc: Constructor
//--------------------------------------------------------------------------------------
CSample::CSample( const CHAR* strName ) : CFrmApplication( strName ),
                                          m_cube_indices(sizeof(g_cube_indices) / sizeof(g_cube_indices[0])),
                                          m_cube_lines( m_cube_indices / 2)
{
    m_fCurrentTime              = 0.0f;
    m_fStartTime                = FrmGetTime();

    m_is_frozen                 = FALSE;
    m_bRotationOn               = TRUE;

    m_MultiSampleShaderProgram  = NULL;
    m_pLogoTexture              = NULL;

    m_OpenGLESVersion           = GLES3;

    m_currentTextureIndex       = 0;

 #ifdef __ANDROID__
     fp_glProgramUniformMatrix4fv     = (PFNGLGENPROGRAMUNIFORMMATRIX4FVOESPROC) eglGetProcAddress("glProgramUniformMatrix4fv");
     fp_glTexStorage2DMultisample     = (PFNGLTEXSTORAGE2DMULTISAMPLEOESPROC) eglGetProcAddress("glTexStorage2DMultisample");
 #endif
}
예제 #9
0
/*-------------------------------------------------------------------*//*!
 * \brief   Destroy a sync object and free memory associated with it
 * \ingroup api
 * \param   dpy     Identifier of the display which owns the sync object
 * \param   sync    Sync object handle. 
 * \return  EGL_TRUE if deletion was successful and EGL_FALSE otherwise
 * \error   EGL_BAD_DISPLAY if <dpy> is not a name of a valid EGLDisplay;
 * EGL_NOT_INITIALIZED if the display object associated with the <dpy> has not been initialized;
 * EGL_BAD_PARAMETER if <sync> is not a valid sync object for <dpy>
 * \note    If any eglClientWaitSyncKHR commands are blocking on <sync> when 
 * eglDestroySyncKHR is called, they will be woken up, as if <sync> were signaled. 
 * If no errors are generated, <sync> will no longer be the handle of a valid sync object.
 *//*-------------------------------------------------------------------*/
EGLBoolean eglDestroySyncKHR( EGLDisplay dpy, EGLSyncKHR sync )
{
    PFNEGLDESTROYSYNCKHRPROC destroyPointer = (PFNEGLDESTROYSYNCKHRPROC) eglGetProcAddress("eglDestroySyncKHR");

	if (destroyPointer == NULL)
		{
		return EGL_FALSE;
		}
	else
		{
		return destroyPointer(dpy, sync);
		}
}
예제 #10
0
파일: ohm2013.c 프로젝트: sandb/ohm2013
static void
init(void)
{
   typedef void (*proc)();

#if 1 /* test code */
   proc p = eglGetProcAddress("glMapBufferOES");
   assert(p);
#endif

   glClearColor(0.0, 0.0, 0.0, 0.0);
//   glClearDepth(1.0f);
   create_shaders();
}
예제 #11
0
static GLFWglproc getProcAddress(const char* procname)
{
    _GLFWwindow* window = _glfwPlatformGetCurrentContext();

    if (window->context.egl.client)
    {
        GLFWglproc proc = (GLFWglproc) _glfw_dlsym(window->context.egl.client,
                                                   procname);
        if (proc)
            return proc;
    }

    return eglGetProcAddress(procname);
}
예제 #12
0
void *extgl_GetProcAddress(const char *name) {
    void *t = eglGetProcAddress(name);

    if ( t == NULL ) {
		t = dlsym(lib_gl_handle, name);
		if ( t == NULL )
            printfDebug("Could not locate symbol %s\n", name);
    }

    //if ( t != NULL )
        //printfDebug("Located symbol %s\n", name);

	return t;
}
예제 #13
0
파일: context_rpi.c 프로젝트: ThreeGe/mpv
static void *get_proc_address(const GLubyte *name)
{
    void *p = eglGetProcAddress(name);
    // EGL 1.4 (supported by the RPI firmware) does not necessarily return
    // function pointers for core functions.
    if (!p) {
        void *h = dlopen("/opt/vc/lib/libGLESv2.so", RTLD_LAZY);
        if (h) {
            p = dlsym(h, name);
            dlclose(h);
        }
    }
    return p;
}
예제 #14
0
static Bool
app_init_exts(struct app_data *data)
{
   const char *exts;

   exts = eglQueryString(data->dpy, EGL_EXTENSIONS);
   data->eglCreateImageKHR =
      (PFNEGLCREATEIMAGEKHRPROC) eglGetProcAddress("eglCreateImageKHR");
   data->eglDestroyImageKHR =
      (PFNEGLDESTROYIMAGEKHRPROC) eglGetProcAddress("eglDestroyImageKHR");
   if (!exts || !strstr(exts, "EGL_KHR_image_pixmap") ||
       !data->eglCreateImageKHR || !data->eglDestroyImageKHR) {
      printf("EGL does not support EGL_KHR_image_pixmap\n");
      return False;
   }

   data->target = 0;
   exts = (const char *) glGetString(GL_EXTENSIONS);
   data->glEGLImageTargetTexture2DOES = (PFNGLEGLIMAGETARGETTEXTURE2DOESPROC)
      eglGetProcAddress("glEGLImageTargetTexture2DOES");
   if (exts && data->glEGLImageTargetTexture2DOES) {
      if (strstr(exts, "GL_OES_EGL_image"))
         data->target = GL_TEXTURE_2D;
#ifdef GL_OES_EGL_image_external
      /* prefer external texture */
      if (strstr(exts, "GL_OES_EGL_image_external"))
         data->target = GL_TEXTURE_EXTERNAL_OES;
#endif
   }

   if (!data->target) {
      printf("OpenGL ES does not support sampling from an EGLImage\n");
      return False;
   }

   return True;
}
예제 #15
0
///////////////////////////////////////////////////////////////////////////////////////////////////
// Loads, compiles, and links the shader and then saves the binary code to a file
void compile_program_binary( GLuint shader_program, const char* BINARY_FILENAME)
{
// load the program
    void* buffer = NULL;
    GLint bin_size = -1;
    GLenum bin_format = -1;
// get the length of the binary code to be retrieved
    glGetProgramiv(shader_program, GL_PROGRAM_BINARY_LENGTH_OES, &bin_size);

    switch (bin_size) {
    case GL_INVALID_ENUM: fprintf(stderr, "glGetProgramiv: GL_INVALID_ENUM\n");
        return;

    case GL_INVALID_VALUE: fprintf(stderr, "glGetProgramiv: GL_INVALID_VALUE\n");
        return;

    case GL_INVALID_OPERATION: fprintf(stderr, "glGetProgramiv: GL_INVALID_OPERATION\n");
        return;
    }

    printf("Binary program length: %d bytes\n", bin_size);
    
// retrieve binary code & code format
    buffer = malloc(bin_size);
    GLsizei bytesWritten;
    
    myglGetProgramBinaryOES = (PFNGLGETPROGRAMBINARYOESPROC)eglGetProcAddress("glGetProgramBinaryOES");

    if (!myglGetProgramBinaryOES) {
        fprintf(stderr, "Can not get glGetProgramBinaryOES function");
        exit(EXIT_FAILURE);
    }

    myglGetProgramBinaryOES (shader_program, bin_size, &bytesWritten, &bin_format, buffer);

    
// write binary code to file
    FILE *bShFile = fopen(BINARY_FILENAME, "wb");
    
    if (!bShFile) {
		fprintf(stderr, "Error: cant write compiled shader to file: %s\n", BINARY_FILENAME);
    }

    size_t bytes = fwrite(buffer, bytesWritten, 1, bShFile);
    printf ("Wrote %d bytes to %s. Binary format: 0x%x\n", bytesWritten, BINARY_FILENAME, bin_format);
    
    fclose(bShFile);
    free(buffer);
}
예제 #16
0
static CoglFuncPtr
_cogl_winsys_renderer_get_proc_address (CoglRenderer *renderer,
                                        const char *name)
{
  void *ptr;

  ptr = eglGetProcAddress (name);

  /* eglGetProcAddress doesn't support fetching core API so we need to
     get that separately with GModule */
  if (ptr == NULL)
    g_module_symbol (renderer->libgl_module, name, &ptr);

  return ptr;
}
예제 #17
0
/*-------------------------------------------------------------------*//*!
 * \brief   Signals or unsignals the reusable sync object.  
 * \ingroup api
 * \param   dpy     Identifier of the display which owns the sync object.
 * \param   sync    Sync object handle. 
 * \param   mode    Status of the sync object. There are two possible states: 
 *  EGL_SIGNALED_KHR and EGL_UNSIGNALED_KHR. 
 * \return  EGL_TRUE if an operation was successful and EGL_FALSE otherwise.
 * \note    The error code returned from eglSignalSyncImpl() will be generated
 *//*-------------------------------------------------------------------*/
EGLBoolean eglSignalSyncKHR( EGLDisplay dpy,
                             EGLSyncKHR sync,
                             EGLenum mode )
{
    PFNEGLSIGNALSYNCKHRPROC signalPointer = (PFNEGLSIGNALSYNCKHRPROC) eglGetProcAddress("eglSignalSyncKHR");
	
   if (signalPointer == NULL)
	   {
	   return EGL_FALSE;
       }
   else
	   {
	   return signalPointer(dpy, sync, mode);
	   }
}
예제 #18
0
/*-------------------------------------------------------------------*//*!
 * \brief   Create a sync object for the specified display.
 * \ingroup api
 * \param   dpy     Identifier of the display which will own the sync object
 * \param   type    Type of the sync object. EGL_SYNC_REUSABLE_KHR is only supported
 * \param   attrib_list Attribute-value list specifying attributes of the sync 
 * object, terminated by an attribute entry EGL_NONE
 * \return  Handle for the created sync object if successful, EGL_NO_SYNC_KHR otherwise
 * \error   EGL_BAD_DISPLAY if <dpy> is not a name of a valid EGLDisplay;
 * EGL_NOT_INITIALIZED if the display object associated with the <dpy> has not been initialized;
 * EGL_BAD_ATTRIBUTE if <attrib_list> is neither NULL nor empty (containing only EGL_NONE) or 
 * if <type> is not a supported type of sync object;
 * EGL_BAD_ALLOC if the memory allocation related to sync object is not successful
 * \note    If <type> is EGL_SYNC_REUSABLE_KHR, a reusable sync object is created. 
 * In this case <attrib_list> must be NULL or empty (containing only EGL_NONE).
 *  *//*-------------------------------------------------------------------*/
EGLSyncKHR eglCreateSyncKHR( EGLDisplay dpy,
                       EGLenum condition,
                       const EGLint *attrib_list )
{
    PFNEGLCREATESYNCKHRPROC createPointer = (PFNEGLCREATESYNCKHRPROC) eglGetProcAddress("eglCreateSyncKHR");

	if (createPointer == NULL)
		{
		return EGL_NO_SYNC_KHR;
		}
	else
		{
		return createPointer(dpy, condition, attrib_list);
		}
}
예제 #19
0
파일: gl_rpi.c 프로젝트: jonntd/mpv
static void *get_proc_address(const GLubyte *name)
{
    void *p = eglGetProcAddress(name);
    // It looks like eglGetProcAddress() should work even for builtin
    // functions, but it doesn't work at least with RPI/Broadcom crap.
    // (EGL 1.4, which current RPI firmware pretends to support, definitely
    // is required to return non-extension functions.)
    if (!p) {
        void *h = dlopen("/opt/vc/lib/libGLESv2.so", RTLD_LAZY);
        if (h) {
            p = dlsym(h, name);
            dlclose(h);
        }
    }
    return p;
}
예제 #20
0
/*-------------------------------------------------------------------*//*!
 * \brief   Query an attribute of the sync object  
 * \ingroup api
 * \param   dpy     Identifier of the display which owns the sync object
 * \param   sync    Sync object handle. 
 * \param   attribute   An attribute to be retrieved. 
 * \param   value   Pointer to the value for the requested attribute which will be filled on function return. 
 * \return  EGL_TRUE if an operation was successful and EGL_FALSE otherwise
 * \error   EGL_BAD_DISPLAY if <dpy> is not a name of a valid EGLDisplay;
 * EGL_NOT_INITIALIZED if the display object associated with the <dpy> has not been initialized;
 * EGL_BAD_PARAMETER if <sync> is not a valid sync object for <dpy> or if <value> is not 
 * a valid pointer; EGL_BAD_ATTRIBUTE if <attribute>  does not lie within expected range;
 * EGL_BAD_MATCH if <attribute> is not supported for the type of sync object passed in <sync>
 *//*-------------------------------------------------------------------*/
EGLBoolean eglGetSyncAttribKHR( EGLDisplay dpy,
                                EGLSyncKHR sync,
                                EGLint attribute,
                                EGLint *value )
{
    PFNEGLGETSYNCATTRIBKHRPROC getAttribPointer = (PFNEGLGETSYNCATTRIBKHRPROC) eglGetProcAddress("eglGetSyncAttribKHR");

	if (getAttribPointer == NULL)
		{
		return EGL_FALSE;
		}
	else
		{
		return getAttribPointer(dpy, sync, attribute, value);
		}
}
예제 #21
0
/*-------------------------------------------------------------------*//*!
 * \brief   Blocks the calling thread until the specified sync object 
 * is signaled, or until <timeout> nanoseconds have passed.  
 * \ingroup api
 * \param   dpy     Identifier of the display which owns the sync object.
 * \param   sync    Sync object handle. 
 * \param   flags   If the EGL_FLUSH_COMMANDS_BIT_KHR bit is set in <flags>
 * and <sync> is unsignaled when the function is called, then the equivalent
 * of Flush() will be performed for the current API context.   
 * \param   timeout The thread will be unblocked when <timeout> is expired.
 * If the <timeout> is to zero, the function just test the current status 
 * of the sync object. If the <timeout> is set to EGL_FOREVER_KHR, then the 
 * function does not time out. For all other values, <timeout> is adjusted to 
 * the closest value which may be substantially longer than one nanosecond. 
 * \return  EGL_CONDITION_SATISFIED if <sync> was signaled before
 * the timeout expired, which includes the case when <sync> was already 
 * signaled when eglClientWaitSyncKHR was called; EGL_TIMEOUT_EXPIRED_KHR if the 
 * specified timeout period expired before <sync> was signaled; 
 * EGL_FALSE if an error occurs.
 * \error   EGL_BAD_DISPLAY if <dpy> is not a name of a valid EGLDisplay;
 * EGL_NOT_INITIALIZED if the display object associated with the <dpy> has not been initialized;
 * EGL_BAD_PARAMETER if <sync> is not a valid sync object for <dpy> or 
 * if <flags> does not equal to 0 or EGL_SYNC_FLUSH_COMMAND_BIT_KHR
 * Note\    More than one eglClientWaitSyncKHR may be outstanding on the same <sync> at any given time. 
 * When there are multiple threads blocked on the same <sync> and the sync object is signaled, 
 * all such threads are released, but the order in which they are released is not defined.
 * If a sync object is destroyed while an eglClientWaitSyncKHR is blocking on that object, 
 * eglClientWaitSyncKHR will unblock and return immediately, just as if the sync object 
 * had been signaled prior to being destroyed.
 *//*-------------------------------------------------------------------*/
EGLint eglClientWaitSyncKHR( EGLDisplay dpy,
                             EGLSyncKHR sync,
                             EGLint flags,
                             EGLTimeKHR timeout )
{
    PFNEGLCLIENTWAITSYNCKHRPROC clientWaitPointer = (PFNEGLCLIENTWAITSYNCKHRPROC) eglGetProcAddress("eglClientWaitSyncKHR");

	if (clientWaitPointer == NULL)
		{
		return EGL_FALSE;
		}
	else
		{
		return clientWaitPointer(dpy, sync, flags, timeout);
		}
}
예제 #22
0
static cg_func_ptr_t
_cg_winsys_renderer_get_proc_address(
    cg_renderer_t *renderer, const char *name, bool in_core)
{
    void *ptr = NULL;

    if (!in_core)
        ptr = eglGetProcAddress(name);

    /* eglGetProcAddress doesn't support fetching core API so we need to
       get that separately with c_module_t */
    if (ptr == NULL)
        c_module_symbol(renderer->libgl_module, name, &ptr);

    return ptr;
}
예제 #23
0
static void*
get_proc_address(void* ctx, const gchar* name)
{
    GdkDisplay* display = gdk_display_get_default();

    #ifdef GDK_WINDOWING_WAYLAND
    if (GDK_IS_WAYLAND_DISPLAY(display))
        return eglGetProcAddress(name);
    #endif
    #ifdef GDK_WINDOWING_X11
    if (GDK_IS_X11_DISPLAY(display))
        return (void*)(intptr_t) glXGetProcAddressARB((const GLubyte*) name);
    #endif

    g_return_val_if_reached(NULL);
}
예제 #24
0
	void LoadFunction(const char *name, void **func)
	{
#ifdef USE_GLES3
		*func = (void*)eglGetProcAddress(name);
		if (*func == NULL)
		{
			// Fall back to trying dlsym
			if (self) // Just in case dlopen fails
				*func = dlsym(self, name);
			if (*func == NULL)
			{
				ERROR_LOG(VIDEO, "Couldn't load function %s", name);
				exit(0);
			}
		}
#endif
	}
void *GL2Decoder::s_getProc(const char *name, void *userData)
{
    GL2Decoder *ctx = (GL2Decoder *) userData;

    if (ctx == NULL || ctx->m_GL2library == NULL) {
        return NULL;
    }

    void *func = NULL;
#ifdef USE_EGL_GETPROCADDRESS
    func = (void *) eglGetProcAddress(name);
#endif
    if (func == NULL) {
        func = (void *) ctx->m_GL2library->findSymbol(name);
    }
    return func;
}
예제 #26
0
void* SkANGLEGLContext::GetD3DEGLDisplay(void* nativeDisplay, bool useGLBackend) {
    PFNEGLGETPLATFORMDISPLAYEXTPROC eglGetPlatformDisplayEXT;
    eglGetPlatformDisplayEXT =
        (PFNEGLGETPLATFORMDISPLAYEXTPROC)eglGetProcAddress("eglGetPlatformDisplayEXT");

    if (!eglGetPlatformDisplayEXT) {
        return eglGetDisplay(static_cast<EGLNativeDisplayType>(nativeDisplay));
    }

    EGLDisplay display = EGL_NO_DISPLAY;
    if (useGLBackend) {
        // Try for an ANGLE D3D11 context, fall back to D3D9.
        EGLint attribs[3] = {
              EGL_PLATFORM_ANGLE_TYPE_ANGLE,
              EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE,
              EGL_NONE
        };
        display = eglGetPlatformDisplayEXT(EGL_PLATFORM_ANGLE_ANGLE,
                                            nativeDisplay, attribs);
    } else {
        // Try for an ANGLE D3D11 context, fall back to D3D9, and finally GL.
        EGLint attribs[3][3] = {
            {
                EGL_PLATFORM_ANGLE_TYPE_ANGLE,
                EGL_PLATFORM_ANGLE_TYPE_D3D11_ANGLE,
                EGL_NONE
            },
            {
                EGL_PLATFORM_ANGLE_TYPE_ANGLE,
                EGL_PLATFORM_ANGLE_TYPE_D3D9_ANGLE,
                EGL_NONE
            },
            {
                EGL_PLATFORM_ANGLE_TYPE_ANGLE,
                EGL_PLATFORM_ANGLE_TYPE_OPENGL_ANGLE,
                EGL_NONE
            }
        };
        for (int i = 0; i < 3 && display == EGL_NO_DISPLAY; ++i) {
            display = eglGetPlatformDisplayEXT(EGL_PLATFORM_ANGLE_ANGLE,
                                                nativeDisplay, attribs[i]);
        }
    }
    return display;
}
void CEglTest_LocalTestStep_EndpointApiExposure::ProcAddressL(const char *aProcName)
    {
    //Convert the 8bit string to a 16 bit descriptor for logging.
    //None of the function names are longer than 128 chars.
    TBuf<128> procName;
    procName.Copy(TPtrC8((TText8*)aProcName));

    //Attempt to get the function pointer. We are expecting to fail since we are outside wserv.
    if(eglGetProcAddress(aProcName) != NULL)
        {
        ERR_PRINTF2(_L("Incorrect result for funcPtr: %S"), &procName);
        User::Leave(KErrUnknown);
        }
    else
        {
        INFO_PRINTF2(_L("Correct result for funcPtr: %S"), &procName);
        }
    }
예제 #28
0
RenderTexture::RenderTexture(int width, int height, int sample_count, GLenum target) :
        Texture(new GLTexture(target)), target_(target),
        width_(width), height_(height), sample_count_(sample_count),
        back_color_{0, 0, 0}, use_stencil_(0),
        renderTexture_gl_render_buffer_(new GLRenderBuffer()),
        renderTexture_gl_frame_buffer_(new GLFrameBuffer()) {
    initialize(width, height);
    if (target_ == GL_TEXTURE_2D_ARRAY) {
        PFNGLFRAMEBUFFERTEXTUREMULTISAMPLEMULTIVIEWOVRPROC glFramebufferTextureMultisampleMultiviewOVR =
                (PFNGLFRAMEBUFFERTEXTUREMULTISAMPLEMULTIVIEWOVRPROC) eglGetProcAddress(
                        "glFramebufferTextureMultisampleMultiviewOVR");
        glBindFramebuffer(GL_FRAMEBUFFER, 0);
        glBindTexture(target_, gl_texture_->id());
        glTexImage3D(target, 0, GL_RGBA8, width, height, 2, 0, GL_RGBA,
                     GL_UNSIGNED_BYTE, 0);
        glBindTexture(target_, 0);
        createArrayTexture(frameBufferDepthTextureId, width_, height_, GL_DEPTH_COMPONENT16);
        glBindFramebuffer(GL_DRAW_FRAMEBUFFER, renderTexture_gl_frame_buffer_->id());
        glFramebufferTextureMultisampleMultiviewOVR(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
                                                    gl_texture_->id(), 0, sample_count_, 0, 2);
        glFramebufferTextureMultisampleMultiviewOVR(GL_DRAW_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
                                                    frameBufferDepthTextureId, 0, sample_count_, 0,
                                                    2);
    } else {
        glBindTexture(target_, gl_texture_->id());
        glTexImage2D(target_, 0, GL_RGBA, width_, height_, 0, GL_RGBA,
                     GL_UNSIGNED_BYTE, 0);
        glBindTexture(target_, 0);

        glBindRenderbuffer(GL_RENDERBUFFER, renderTexture_gl_render_buffer_->id());
        MSAA::glRenderbufferStorageMultisampleIMG(GL_RENDERBUFFER, sample_count,
                                                  GL_DEPTH_COMPONENT16, width, height);
        glBindRenderbuffer(GL_RENDERBUFFER, 0);

        glBindFramebuffer(GL_FRAMEBUFFER, renderTexture_gl_frame_buffer_->id());

        MSAA::glFramebufferTexture2DMultisample(GL_FRAMEBUFFER,
                                                GL_COLOR_ATTACHMENT0, target_, gl_texture_->id(), 0,
                                                sample_count);

        glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
                                  GL_RENDERBUFFER, renderTexture_gl_render_buffer_->id());
    }
}
예제 #29
0
void
piglit_init(int argc, char **argv)
{
	GLuint tex;

	piglit_require_extension("GL_OES_draw_texture");
	piglit_glDrawTexiOES = (PFNGLDRAWTEXIOESPROC)
		eglGetProcAddress("glDrawTexiOES");
	if (!piglit_glDrawTexiOES)
		piglit_report_result(PIGLIT_FAIL);

	piglit_ortho_projection(piglit_width, piglit_height, GL_FALSE);

	tex = piglit_rgbw_texture(GL_RGBA,
			TEXTURE_SIZE, TEXTURE_SIZE, GL_FALSE, GL_TRUE, 0);

	glBindTexture(GL_TEXTURE_2D, tex);
	glEnable(GL_TEXTURE_2D);
}
예제 #30
0
    virtual bool initialize()
    {
        mPostSubBufferNV = (PFNEGLPOSTSUBBUFFERNVPROC)eglGetProcAddress("eglPostSubBufferNV");
        if (!mPostSubBufferNV)
        {
            std::cerr << "Could not load eglPostSubBufferNV.";
            return false;
        }

        const std::string vs = SHADER_SOURCE
        (
            uniform mat4 u_mvpMatrix;
            attribute vec4 a_position;
            attribute vec2 a_texcoord;
            varying vec2 v_texcoord;
            void main()
            {
                gl_Position = u_mvpMatrix * a_position;
                v_texcoord = a_texcoord;
            }