nanogl.cpp

   1 /*
   2 Copyright (C) 2007-2009 Olli Hinkka
   3
   4 This program is free software; you can redistribute it and/or
   5 modify it under the terms of the GNU General Public License
   6 as published by the Free Software Foundation; either version 2
   7 of the License, or (at your option) any later version.
   8
   9 This program is distributed in the hope that it will be useful,
  10 but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
  12
  13 See the GNU General Public License for more details.
  14
  15 You should have received a copy of the GNU General Public License
  16 along with this program; if not, write to the Free Software
  17 Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  18
  19 */
  20
  21 #define LOG_TAG "nanoGL"
  22
  23 #include <stdio.h>
  24 #include <stdlib.h>
  25
  26 //#include <cutils/log.h>
  27
  28 #include "nanogl.h"
  29 #include "glesinterface.h"
  30 #include "gl.h"
  31
  32 #define DEBUG_NANO 0
  33
  34 #ifdef __ANDROID__
  35 #include <android/log.h>
  36 #define LOG __android_log_print
  37
  38 #define LOGI( ... ) __android_log_print( ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__ )
  39 #define LOGD( ... )   \
  40         if ( DEBUG_NANO ) \
  41         __android_log_print( ANDROID_LOG_DEBUG, LOG_TAG, __VA_ARGS__ )
  42 #define LOGE( ... ) __android_log_print( ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__ )
  43 #define LOGW( ... ) __android_log_print( ANDROID_LOG_WARN, LOG_TAG, __VA_ARGS__ )
  44 #else
  45 #ifndef _MSC_VER
  46 #define LOGI( ... )             \
  47         printf( "I: " __VA_ARGS__ ); \
  48         printf( "\n" )
  49 #define LOGD( ... )                 \
  50         if ( DEBUG_NANO )               \
  51         {                               \
  52                 printf( "D: " __VA_ARGS__ ); \
  53                 printf( "\n" );             \
  54         }
  55 #define LOGE( ... )             \
  56         printf( "E: " __VA_ARGS__ ); \
  57         printf( "\n" )
  58 #define LOGW( ... )             \
  59         printf( "W: " __VA_ARGS__ ); \
  60         printf( "\n" )
  61 #else
  62 #define LOGI printf
  63 #define LOGD printf
  64 #define LOGE printf
  65 #define LOGW printf
  66
  67 #endif
  68 #endif
  69
  70 #ifdef _WIN32
  71 #include <windows.h>
  72 #define loadDriver( x ) LoadLibraryA( x )
  73 #define procAddress( x, y ) (( void * ) GetProcAddress( (HINSTANCE)x, y ))
  74 #define freeDriver( x ) FreeLibrary( (HINSTANCE)x )
  75 #define GL_LIB "opengl32.dll"
  76 #define GLES_LIB "GLESv1_CM.dll"
  77 #define EGL_LIB "EGL.dll"
  78 #else
  79 #include <dlfcn.h>
  80 #define loadDriver( x ) dlopen( x, RTLD_NOW | RTLD_LOCAL )
  81 #define procAddress( x, y ) dlsym( x, y )
  82 #define freeDriver( x ) dlclose() x )
  83 #define GL_LIB "libGL.so.1"
  84 #define GLES_LIB "libGLESv1_CM.so"
  85 #define EGL_LIB "libEGL.so"
  86 #endif
  87
  88 //#define GL_ENTRY(_r, _api, ...) #_api,
  89
  90 static char const *const gl_names[] = {
  91 #include "funcnames.h"
  92     NULL};
  93
  94 //const char * driver;
  95
  96 static void *glesLib = NULL;
  97
  98 GlESInterface *glEsImpl = NULL;
  99
 100 extern void InitGLStructs( );
 101 #ifdef WIN32
 102 void APIENTRY gl_unimplemented( GLenum none )
 103 {
 104 #ifndef USE_CORE_PROFILE
 105         LOGE( "Called unimplemented OpenGL ES API\n" );
 106 #endif
 107 }
 108 #else // make glGetString not crash
 109 const char * APIENTRY gl_unimplemented( GLenum none )
 110 {
 111 #ifndef USE_CORE_PROFILE
 112         LOGE( "Called unimplemented OpenGL ES API\n" );
 113 #endif
 114         return "";
 115 }
 116 #endif
 117 #ifdef XASH_SDL
 118 #define NANOGL_SDL
 119 #endif
 120 #ifdef __ANDROID__
 121 #define NANOGL_EGL
 122 #endif
 123 #ifdef NANOGL_SDL
 124 #include "SDL.h"
 125 #endif
 126
 127 #ifdef NANOGL_EGL
 128 void *eglLib;
 129 #endif
 130
 131 void *nanoGL_GetProcAddress( const char *name )
 132 {
 133         void *addr = NULL;
 134 #ifdef NANOGL_SDL
 135         addr = SDL_GL_GetProcAddress( name );
 136         if ( !addr )
 137 #endif
 138         addr = procAddress( glesLib, name );
 139 #ifdef NANOGL_EGL
 140         if( !addr )
 141                 addr = procAddress( eglLib, name );
 142         if( !addr && glEsImpl->eglGetProcAddress )
 143                 addr = (void *)glEsImpl->eglGetProcAddress( name );
 144 #endif
 145         return addr;
 146 }
 147
 148 #if 1
 149 int nanoGL_Init( void)
 150 {
 151         // load GL API calls
 152         char const *const *api;
 153         api = gl_names;
 154         int count = 0;
 155
 156         // alloc space
 157         if ( !glEsImpl )
 158                 glEsImpl = (GlESInterface *)malloc( sizeof( GlESInterface ) );
 159         memset( glEsImpl, 0, sizeof( GlESInterface ) );
 160
 161 #ifdef NANOGL_EGL
 162         eglLib = loadDriver( EGL_LIB );
 163 #endif
 164 #ifdef USE_CORE_PROFILE
 165         glesLib = loadDriver( GL_LIB );
 166 #else
 167         glesLib = loadDriver( GLES_LIB );
 168 #endif
 169
 170         // nanoGL interface pointer
 171         void **ptr = (void **)( glEsImpl );
 172
 173         while ( *api )
 174         {
 175                 void *f;
 176
 177                 f = nanoGL_GetProcAddress( *api);
 178
 179         #ifdef USE_CORE_PROFILE
 180                 // Hack: try ARB and EXT suffix
 181                 if ( f == NULL )
 182                 {
 183                         char namearb[256];
 184                         snprintf( namearb, 256, "%sARB", *api );
 185                         f = nanoGL_GetProcAddress( namearb );
 186                 }
 187                 if ( f == NULL )
 188                 {
 189                         char namearb[256];
 190                         snprintf( namearb, 256, "%sEXT", *api );
 191                         f = nanoGL_GetProcAddress( namearb );
 192                 }
 193         #endif
 194                 if ( f == NULL )
 195                 {
 196                         LOGW( "<%s> not found.", *api);
 197                         f = (void*)gl_unimplemented;
 198                 }
 199                 else
 200                 {
 201                         LOGD( "<%s> @ 0x%p\n", *api, f );
 202                         count++;
 203                 }
 204
 205                 *ptr++ = f;
 206                 api++;
 207         }
 208
 209         InitGLStructs();
 210
 211         // it has loaded something, maybe it will work
 212         if( count > 10 )
 213                 return 1;
 214         else
 215                 return 0;
 216 }
 217 #else
 218
 219 static int CreateGlEsInterface( const char *name, void *lib, void *lib1, void *default_func )
 220 {
 221         // alloc space
 222         if ( !glEsImpl )
 223                 glEsImpl = (GlESInterface *)malloc( sizeof( GlESInterface ) );
 224
 225         if ( !glEsImpl )
 226         {
 227                 return 0;
 228         }
 229
 230         // load GL API calls
 231         char const *const *api;
 232         api = gl_names;
 233
 234         // nanoGL interface pointer
 235         void **ptr = (void **)( glEsImpl );
 236
 237         while ( *api )
 238         {
 239                 void *f;
 240
 241                 f = dlsym( lib, *api ); // try libGLESxx_CM.so
 242
 243 #ifdef USE_CORE_PROFILE
 244                 // Hack: try ARB and EXT suffix
 245                 if ( f == NULL )
 246                 {
 247                         char namearb[256];
 248                         snprintf( namearb, 256, "%sARB", *api );
 249                         f = dlsym( lib, namearb );
 250                 }
 251                 if ( f == NULL )
 252                 {
 253                         char namearb[256];
 254                         snprintf( namearb, 256, "%sEXT", *api );
 255                         f = dlsym( lib, namearb );
 256                 }
 257 #endif
 258                 if ( f == NULL )
 259                 {
 260                         LOGW( "<%s> not found in %s. Trying libEGL.so.", *api, name ); //driver);
 261
 262                         // try lib1
 263                         if ( lib1 )
 264                         {
 265                                 f = dlsym( lib1, *api ); // libEGL.so
 266
 267                                 if ( f == NULL )
 268                                 {
 269                                         LOGE( "<%s> not found in libEGL.so", *api );
 270                                         if ( glEsImpl->eglGetProcAddress && ( (void *)glEsImpl->eglGetProcAddress != (void *)gl_unimplemented ) )
 271                                                 f = (void *)glEsImpl->eglGetProcAddress( *api );
 272                                         if ( f == NULL )
 273                                                 f = (void *)default_func; //(void*)gl_unimplemented;
 274                                 }
 275                                 else
 276                                 {
 277                                         LOGD( "<%s> @ 0x%p\n", *api, f );
 278                                 }
 279                         }
 280                         else
 281                         {
 282                                 LOGE( "libEGL.so not loaded!" );
 283                                 if ( glEsImpl->eglGetProcAddress && ( (void *)glEsImpl->eglGetProcAddress != (void *)gl_unimplemented ) )
 284                                         f = (void *)glEsImpl->eglGetProcAddress( *api );
 285                                 if ( !f )
 286                                         f = (void *)default_func;
 287                         }
 288                 }
 289                 else
 290                 {
 291                         LOGD( "<%s> @ 0x%p\n", *api, f );
 292                 }
 293
 294                 *ptr++ = f;
 295                 api++;
 296         }
 297
 298         return 1;
 299 }
 300
 301 // Load using the dynamic loader
 302 static int loadDriver( const char *name )
 303 {
 304         glesLib = dlopen( name, RTLD_NOW | RTLD_LOCAL );
 305         int rc  = ( glesLib ) ? 1 : 0;
 306         return rc;
 307 }
 308
 309 /**
 310  * Init
 311  */
 312 #ifdef _WIN32
 313 int nanoGL_Init( )
 314 {
 315         const char *lib1 = "opengl32.dll"; // Has both gl* & egl* funcs SDK < 1.5
 316         const char *lib2 = "opengl32.dll"; // Only gl* funcs SDK >= 1.5
 317         const char *lib3 = "opengl32.dll"; // Only egl* funcs SDK >= 1.5
 318         const char *driver;
 319
 320         // load lib
 321         LOGI( "nanoGL: Init loading driver %s\n", lib1 );
 322         //LOG (ANDROID_LOG_DEBUG, LOG_TAG, "nanoGL: Init loading driver %s\n", lib1);
 323
 324         if ( !loadDriver( lib1 ) )
 325         {
 326                 LOGE( "Failed to load driver %s. Trying %s\n", lib1, lib2 );
 327
 328                 if ( !loadDriver( lib2 ) )
 329                 {
 330                         LOGE( "Failed to load  %s.\n", lib2 );
 331                         return 0;
 332                 }
 333                 else
 334                         driver = lib2;
 335         }
 336         else
 337                 driver = lib1;
 338
 339         void *eglLib;
 340
 341         //if ( strcmp(driver, lib2) == 0 ) {
 342         LOGD( "**** Will Load EGL subs from %s ****", lib3 );
 343
 344         eglLib = dlopen( lib3, RTLD_NOW | RTLD_LOCAL );
 345
 346         if ( !eglLib )
 347         {
 348                 LOGE( "Failed to load %s", lib3 );
 349         }
 350         //}
 351
 352         // Load API gl* for 1.5+  else egl* gl*
 353         //if (CreateGlEsInterface(driver, glesLib, eglLib, NULL) == -1)
 354         if ( !CreateGlEsInterface( driver, glesLib, eglLib, (void *)gl_unimplemented ) == -1 )
 355         {
 356                 // release lib
 357                 LOGE( "CreateGlEsInterface failed." );
 358
 359                 dlclose( glesLib );
 360                 return 0;
 361         }
 362
 363         // Init nanoGL
 364         InitGLStructs( );
 365         return 1;
 366 }
 367 #else
 368 int nanoGL_Init( )
 369 {
 370         const char *lib1 = "libGLESv1_CM.so"; // Has both gl* & egl* funcs SDK < 1.5
 371         const char *lib2 = "libGLESv2.so";    // Only gl* funcs SDK >= 1.5
 372         const char *lib3 = "libEGL.so";       // Only egl* funcs SDK >= 1.5
 373         const char *driver;
 374
 375         // load lib
 376         LOGI( "nanoGL: Init loading driver %s\n", lib1 );
 377         //LOG (ANDROID_LOG_DEBUG, LOG_TAG, "nanoGL: Init loading driver %s\n", lib1);
 378
 379         if ( !loadDriver( lib1 ) )
 380         {
 381                 LOGE( "Failed to load driver %s. Trying %s\n", lib1, lib2 );
 382
 383                 if ( !loadDriver( lib2 ) )
 384                 {
 385                         LOGE( "Failed to load  %s.\n", lib2 );
 386                         return 0;
 387                 }
 388                 else
 389                         driver = lib2;
 390         }
 391         else
 392                 driver = lib1;
 393
 394         void *eglLib;
 395
 396         //if ( strcmp(driver, lib2) == 0 ) {
 397         LOGD( "**** Will Load EGL subs from %s ****", lib3 );
 398
 399         eglLib = dlopen( lib3, RTLD_NOW | RTLD_LOCAL );
 400
 401         if ( !eglLib )
 402         {
 403                 LOGE( "Failed to load %s", lib3 );
 404         }
 405         //}
 406
 407         // Load API gl* for 1.5+  else egl* gl*
 408         //if (CreateGlEsInterface(driver, glesLib, eglLib, NULL) == -1)
 409         if ( !CreateGlEsInterface( driver, glesLib, eglLib, (void *)gl_unimplemented ) == -1 )
 410         {
 411                 // release lib
 412                 LOGE( "CreateGlEsInterface failed." );
 413
 414                 dlclose( glesLib );
 415                 return 0;
 416         }
 417
 418 #ifdef __ANDROID__
 419         // somewhy it does not initialize correctly
 420         *( (void **)&glEsImpl->glGenFramebuffers ) = (void *)glEsImpl->eglGetProcAddress( "glGenFramebuffersOES" );
 421         *( (void **)&glEsImpl->glGenRenderbuffers ) = (void *)glEsImpl->eglGetProcAddress( "glGenRenderbuffersOES" );
 422         *( (void **)&glEsImpl->glRenderbufferStorage ) = (void *)glEsImpl->eglGetProcAddress( "glRenderbufferStorageOES" );
 423         *( (void **)&glEsImpl->glBindFramebuffer ) = (void *)glEsImpl->eglGetProcAddress( "glBindFramebufferOES" );
 424         *( (void **)&glEsImpl->glBindRenderbuffer ) = (void *)glEsImpl->eglGetProcAddress( "glBindRenderbufferOES" );
 425         *( (void **)&glEsImpl->glFramebufferTexture2D ) = (void *)glEsImpl->eglGetProcAddress( "glFramebufferTexture2DOES" );
 426         *( (void **)&glEsImpl->glDeleteRenderbuffers ) = (void *)glEsImpl->eglGetProcAddress( "glDeleteRenderbuffersOES" );
 427         *( (void **)&glEsImpl->glDeleteFramebuffers ) = (void *)glEsImpl->eglGetProcAddress( "glDeleteFramebuffersOES" );
 428         *( (void **)&glEsImpl->glFramebufferRenderbuffer ) = (void *)glEsImpl->eglGetProcAddress( "glFramebufferRenderbufferOES" );
 429         *( (void **)&glEsImpl->glTexGeniOES ) = (void *)glEsImpl->eglGetProcAddress( "glTexGeniOES" );
 430         *( (void **)&glEsImpl->glTexGenfvOES ) = (void *)glEsImpl->eglGetProcAddress( "glTexGenfv" );
 431
 432
 433 #endif
 434
 435         // Init nanoGL
 436         InitGLStructs( );
 437         return 1;
 438 }
 439 #endif
 440
 441 #endif
 442 void nanoGL_Destroy( )
 443 {
 444         LOGD( "nanoGL_Destroy" );
 445
 446         if ( glEsImpl )
 447         {
 448                 free( glEsImpl );
 449                 glEsImpl = NULL;
 450         }
 451
 452         // release lib
 453         dlclose( glesLib );
 454 }