diff options
Diffstat (limited to 'emulator/opengl/tests/gles_android_wrapper')
21 files changed, 4376 insertions, 0 deletions
diff --git a/emulator/opengl/tests/gles_android_wrapper/Android.mk b/emulator/opengl/tests/gles_android_wrapper/Android.mk new file mode 100644 index 0000000..f7c8fed --- /dev/null +++ b/emulator/opengl/tests/gles_android_wrapper/Android.mk @@ -0,0 +1,80 @@ +LOCAL_PATH := $(call my-dir) + +#### libGLESv1_CM_emul.so +$(call emugl-begin-shared-library,libGLESv1_CM_emul) +$(call emugl-import,libGLESv1_enc) +$(call emugl-gen-wrapper,$(EMUGL_PATH)/system/GLESv1_enc,gl) +$(call emugl-set-shared-library-subpath,egl) + +LOCAL_SRC_FILES += glesv1_emul_ifc.cpp + +$(call emugl-end-module) + +emulatorOpengl := $(LOCAL_PATH)/../.. +logTag := -DLOG_TAG=\"eglWrapper\" +EMUGEN = $(BUILD_OUT_EXECUTABLES)/emugen +## comment for no debug +#debugFlags = -g -O0 + +#### libGLESv2_CM_emul.so +$(call emugl-begin-shared-library, libGLESv2_emul) +$(call emugl-import,libGLESv2_enc) +$(call emugl-gen-wrapper,$(EMUGL_PATH)/system/GLESv2_enc,gl2) +LOCAL_SRC_FILES += glesv2_emul_ifc.cpp +$(call emugl-set-shared-library-subpath,egl) +$(call emugl-end-module) + +##### libEGL_emul.so ########### + +# THE FOLLOWING DOESN'T WORK YET +# +$(call emugl-begin-shared-library,libEGL_emul) +$(call emugl-import,libut_rendercontrol_enc libGLESv1_CM_emul libGLESv2_emul libOpenglSystemCommon) + +$(call emugl-set-shared-library-subpath,egl) +LOCAL_CFLAGS += $(logTag) + +LOCAL_SRC_FILES := \ + egl.cpp \ + egl_dispatch.cpp \ + ServerConnection.cpp \ + ThreadInfo.cpp + +$(call emugl-end-module) + +#### egl.cfg #### + +# Ensure that this file is only copied to emulator-specific builds. +# Other builds are device-specific and will provide their own +# version of this file to point to the appropriate HW EGL libraries. +# +ifneq (,$(filter full full_x86 sdk sdk_x86,$(TARGET_PRODUCT))) +ifeq (,$(BUILD_EMULATOR_OPENGL_DRIVER)) +include $(CLEAR_VARS) + +LOCAL_MODULE := egl.cfg +LOCAL_SRC_FILES := $(LOCAL_MODULE) + +LOCAL_MODULE_PATH := $(TARGET_OUT)/lib/egl +LOCAL_MODULE_TAGS := debug +LOCAL_MODULE_CLASS := ETC + +include $(BUILD_PREBUILT) +endif # building 'real' driver BUILD_EMULATOR_OPENGL_DRIVER +endif # TARGET_PRODUCT in 'full sdk full_x86 sdk_x86' + +#### gles_emul.cfg #### +include $(CLEAR_VARS) + +LOCAL_MODULE := gles_emul.cfg +LOCAL_SRC_FILES := $(LOCAL_MODULE) + +LOCAL_MODULE_PATH := $(TARGET_OUT)/etc +LOCAL_MODULE_TAGS := debug +LOCAL_MODULE_CLASS := ETC + +include $(BUILD_PREBUILT) + + + + diff --git a/emulator/opengl/tests/gles_android_wrapper/ApiInitializer.h b/emulator/opengl/tests/gles_android_wrapper/ApiInitializer.h new file mode 100644 index 0000000..793c735 --- /dev/null +++ b/emulator/opengl/tests/gles_android_wrapper/ApiInitializer.h @@ -0,0 +1,42 @@ +/* +* Copyright 2011 The Android Open Source Project +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#ifndef _API_INITIALIZER_H_ +#define _API_INITIALIZER_H_ +#include <stdlib.h> +#include <dlfcn.h> + +class ApiInitializer { +public: + ApiInitializer(void *dso) : + m_dso(dso) { + } + static void *s_getProc(const char *name, void *userData) { + ApiInitializer *self = (ApiInitializer *)userData; + return self->getProc(name); + } +private: + void *m_dso; + void *getProc(const char *name) { + void *symbol = NULL; + if (m_dso) { + symbol = dlsym(m_dso, name); + } + return symbol; + } +}; + +#endif diff --git a/emulator/opengl/tests/gles_android_wrapper/CleanSpec.mk b/emulator/opengl/tests/gles_android_wrapper/CleanSpec.mk new file mode 100644 index 0000000..f56383a --- /dev/null +++ b/emulator/opengl/tests/gles_android_wrapper/CleanSpec.mk @@ -0,0 +1,50 @@ +# Copyright (C) 2007 The Android Open Source Project +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +# If you don't need to do a full clean build but would like to touch +# a file or delete some intermediate files, add a clean step to the end +# of the list. These steps will only be run once, if they haven't been +# run before. +# +# E.g.: +# $(call add-clean-step, touch -c external/sqlite/sqlite3.h) +# $(call add-clean-step, rm -rf $(PRODUCT_OUT)/obj/STATIC_LIBRARIES/libz_intermediates) +# +# Always use "touch -c" and "rm -f" or "rm -rf" to gracefully deal with +# files that are missing or have been moved. +# +# Use $(PRODUCT_OUT) to get to the "out/target/product/blah/" directory. +# Use $(OUT_DIR) to refer to the "out" directory. +# +# If you need to re-do something that's already mentioned, just copy +# the command and add it to the bottom of the list. E.g., if a change +# that you made last week required touching a file and a change you +# made today requires touching the same file, just copy the old +# touch step and add it to the end of the list. +# +# ************************************************ +# NEWER CLEAN STEPS MUST BE AT THE END OF THE LIST +# ************************************************ + +# For example: +#$(call add-clean-step, rm -rf $(OUT_DIR)/target/common/obj/APPS/AndroidTests_intermediates) +#$(call add-clean-step, rm -rf $(OUT_DIR)/target/common/obj/JAVA_LIBRARIES/core_intermediates) +#$(call add-clean-step, find $(OUT_DIR) -type f -name "IGTalkSession*" -print0 | xargs -0 rm -f) +#$(call add-clean-step, rm -rf $(PRODUCT_OUT)/data/*) + +# ************************************************ +# NEWER CLEAN STEPS MUST BE AT THE END OF THE LIST +# ************************************************ +$(call add-clean-step, rm -rf $(OUT_DIR)/target/common/obj/SHARED_LIBRARIES/libGLES_emul_intermediates) diff --git a/emulator/opengl/tests/gles_android_wrapper/ServerConnection.cpp b/emulator/opengl/tests/gles_android_wrapper/ServerConnection.cpp new file mode 100644 index 0000000..ff4e390 --- /dev/null +++ b/emulator/opengl/tests/gles_android_wrapper/ServerConnection.cpp @@ -0,0 +1,125 @@ +/* +* Copyright (C) 2011 The Android Open Source Project +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ +#include <stdio.h> +#include <stdlib.h> +#include "ServerConnection.h" +#include "TcpStream.h" +#include "QemuPipeStream.h" +#include <cutils/log.h> +#include "ThreadInfo.h" + +gl_client_context_t *ServerConnection::s_getGlContext() +{ + EGLThreadInfo *ti = getEGLThreadInfo(); + if (ti->serverConn) { + return ti->serverConn->m_glEnc; + } + return NULL; +} + +gl2_client_context_t *ServerConnection::s_getGl2Context() +{ + EGLThreadInfo *ti = getEGLThreadInfo(); + if (ti->serverConn) { + return ti->serverConn->m_gl2Enc; + } + return NULL; +} + +ServerConnection *ServerConnection::s_getServerConnection() +{ + EGLThreadInfo *ti = getEGLThreadInfo(); + if (!ti->serverConn) + { + ti->serverConn = new ServerConnection(); + if (ti->serverConn->create() < 0) { + delete ti->serverConn; + ti->serverConn = NULL; + } + } + + return ti->serverConn; +} + + +ServerConnection::ServerConnection() : + m_stream(NULL), + m_glEnc(NULL), + m_ut_enc(NULL) +{ +} + +ServerConnection::~ServerConnection() +{ + delete m_ut_enc; + delete m_glEnc; + delete m_stream; +} + + + +int ServerConnection::create(size_t bufsize, + const char *defaultServer) +{ + /* XXX: Make configurable through system property */ + int useQemuPipe = 1; + + if (m_stream != NULL) delete(m_stream); + + if (useQemuPipe) { + QemuPipeStream* pipeStream = new QemuPipeStream(bufsize); + + if (pipeStream->connect() < 0) { + ALOGE("couldn't connect to host server\n"); + delete pipeStream; + return -1; + } + m_stream = pipeStream; + } + else /* !useQemuPipe */ + { + TcpStream* tcpStream = new TcpStream(bufsize); + + char *s = getenv(ENV_RGL_SERVER); + char *hostname; + if (s == NULL) { + hostname = strdup(defaultServer); + } else { + hostname = strdup(s); + } + + if (tcpStream->connect(hostname, CODEC_SERVER_PORT) < 0) { + ALOGE("couldn't connect to %s\n", hostname); + free(hostname); + delete tcpStream; + return -1; + } + LOGI("connecting to server %s\n", hostname); + free(hostname); + + m_stream = tcpStream; + } + + m_glEnc = new GLEncoder(m_stream); + m_glEnc->setContextAccessor(s_getGlContext); + + m_gl2Enc = new GL2Encoder(m_stream); + m_gl2Enc->setContextAccessor(s_getGl2Context); + + m_ut_enc = new ut_rendercontrol_encoder_context_t(m_stream); + return 0; +} + diff --git a/emulator/opengl/tests/gles_android_wrapper/ServerConnection.h b/emulator/opengl/tests/gles_android_wrapper/ServerConnection.h new file mode 100644 index 0000000..84f40d8 --- /dev/null +++ b/emulator/opengl/tests/gles_android_wrapper/ServerConnection.h @@ -0,0 +1,55 @@ +/* +* Copyright (C) 2011 The Android Open Source Project +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ +#ifndef _SERVER_CONNECTION_H +#define _SERVER_CONNECTION_H + +#include "GLEncoder.h" +#include "GL2Encoder.h" +#include "IOStream.h" +#include "codec_defs.h" +#include "ut_rendercontrol_enc.h" +#include <pthread.h> + +#define ENV_RGL_SERVER "RGL_SERVER" +#define RGL_DEFAULT_SERVER "10.0.2.2" + +class ServerConnection { +public: + ~ServerConnection(); + int create(size_t buf_size = 4 * 1024 * 1024, const char *defaultServer = RGL_DEFAULT_SERVER); + static gl_client_context_t *s_getGlContext(); + static ServerConnection *s_getServerConnection(); + static gl2_client_context_t *s_getGl2Context(); + GLEncoder *glEncoder() { return m_glEnc; } + GL2Encoder *gl2Encoder() { return m_gl2Enc; } + ut_rendercontrol_encoder_context_t * utEnc() { return m_ut_enc; } + +private: + ServerConnection(); + +private: + static pthread_key_t s_glKey; + static pthread_key_t s_connectionKey; + static void s_initKeys(); + IOStream *m_stream; + GLEncoder *m_glEnc; + GL2Encoder *m_gl2Enc; + ut_rendercontrol_encoder_context_t *m_ut_enc; + +}; + + +#endif diff --git a/emulator/opengl/tests/gles_android_wrapper/ThreadInfo.cpp b/emulator/opengl/tests/gles_android_wrapper/ThreadInfo.cpp new file mode 100644 index 0000000..5bf6a7d --- /dev/null +++ b/emulator/opengl/tests/gles_android_wrapper/ThreadInfo.cpp @@ -0,0 +1,39 @@ +/* +* Copyright (C) 2011 The Android Open Source Project +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ +#include "ThreadInfo.h" +#include "cutils/threads.h" + +thread_store_t s_tls = THREAD_STORE_INITIALIZER; + +static void tlsDestruct(void *ptr) +{ + if (ptr) { + EGLThreadInfo *ti = (EGLThreadInfo *)ptr; + delete ti->serverConn; + delete ti; + } +} + +EGLThreadInfo *getEGLThreadInfo() +{ + EGLThreadInfo *ti = (EGLThreadInfo *)thread_store_get(&s_tls); + if (ti) return ti; + + ti = new EGLThreadInfo(); + thread_store_set(&s_tls, ti, tlsDestruct); + + return ti; +} diff --git a/emulator/opengl/tests/gles_android_wrapper/ThreadInfo.h b/emulator/opengl/tests/gles_android_wrapper/ThreadInfo.h new file mode 100644 index 0000000..f748a39 --- /dev/null +++ b/emulator/opengl/tests/gles_android_wrapper/ThreadInfo.h @@ -0,0 +1,49 @@ +/* +* Copyright (C) 2011 The Android Open Source Project +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ +#ifndef _THREAD_INFO_H +#define _THREAD_INFO_H + +#include "ServerConnection.h" +#include <EGL/egl.h> + +struct EGLWrapperContext +{ + EGLWrapperContext(EGLContext p_aglContext, int _version) { + aglContext = p_aglContext; + clientState = NULL; + version = _version; + } + + ~EGLWrapperContext() { + delete clientState; + } + + EGLContext aglContext; + GLClientState *clientState; + int version; +}; + +struct EGLThreadInfo +{ + EGLThreadInfo() : currentContext(NULL), serverConn(NULL) {} + + EGLWrapperContext *currentContext; + ServerConnection *serverConn; +}; + + +EGLThreadInfo *getEGLThreadInfo(); +#endif diff --git a/emulator/opengl/tests/gles_android_wrapper/egl.cfg b/emulator/opengl/tests/gles_android_wrapper/egl.cfg new file mode 100644 index 0000000..891b07d --- /dev/null +++ b/emulator/opengl/tests/gles_android_wrapper/egl.cfg @@ -0,0 +1 @@ +0 0 emul
\ No newline at end of file diff --git a/emulator/opengl/tests/gles_android_wrapper/egl.cpp b/emulator/opengl/tests/gles_android_wrapper/egl.cpp new file mode 100644 index 0000000..1e2e456 --- /dev/null +++ b/emulator/opengl/tests/gles_android_wrapper/egl.cpp @@ -0,0 +1,663 @@ +/* +* Copyright (C) 2011 The Android Open Source Project +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +// +// WARNING -------------------------- WARNING +// This code meant to be used for testing purposes only. It is not production +// level quality. +// Use on your own risk !! +// + +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <dlfcn.h> +#include "egl_dispatch.h" +#include "egl_ftable.h" +#include <cutils/process_name.h> +#include <cutils/log.h> +#include "ServerConnection.h" +#include "ThreadInfo.h" +#include <pthread.h> +#include "gl_wrapper_context.h" +#include "gl2_wrapper_context.h" + +#define GLES_EMUL_TARGETS_FILE "/system/etc/gles_emul.cfg" +// implementation libraries; +#define GLESv1_enc_LIB "/system/lib/libGLESv1_enc.so" +#define GLESv2_enc_LIB "/system/lib/libGLESv2_enc.so" +#define GLES_android_LIB "/system/lib/egl/libGLES_android.so" +// driver libraries; +#define GLESv1_DRIVER "/system/lib/egl/libGLESv1_CM_emul.so" +#define GLESv2_DRIVER "/system/lib/egl/libGLESv2_emul.so" + + +static struct egl_dispatch *s_dispatch = NULL; +pthread_once_t dispatchTablesInitialized = PTHREAD_ONCE_INIT; + +static bool s_needEncode = false; + +static gl_wrapper_context_t *g_gl_dispatch = NULL; +static gl2_wrapper_context_t *g_gl2_dispatch = NULL; + +template <class T> +int initApi(const char *driverLibName, const char *implLibName, T **dispatchTable, T *(*accessor)()) +{ + void *driverLib = dlopen(driverLibName, RTLD_NOW | RTLD_LOCAL); + if (driverLib == NULL) { + ALOGE("failed to load %s : %s\n", driverLibName, dlerror()); + return -1; + } + + typedef T *(*createFcn_t)(void *, T *(*accessor)()); + createFcn_t createFcn; + createFcn = (createFcn_t) dlsym(driverLib, "createFromLib"); + if (createFcn == NULL) { + ALOGE("failed to load createFromLib constructor function\n"); + return -1; + } + + void *implLib = dlopen(implLibName, RTLD_NOW | RTLD_LOCAL); + if (implLib == NULL) { + ALOGE("couldn't open %s", implLibName); + return -2; + } + *dispatchTable = createFcn(implLib, accessor); + if (*dispatchTable == NULL) { + return -3; + } + + // XXX - we do close the impl library since it doesn't have data, as far as we concern. + dlclose(implLib); + + // XXX - we do not dlclose the driver library, so its not initialized when + // later loaded by android - is this required? + ALOGD("loading %s into %s complete\n", implLibName, driverLibName); + return 0; + +} + +static gl_wrapper_context_t *getGLContext() +{ + return g_gl_dispatch; +} + +static gl2_wrapper_context_t *getGL2Context() +{ + return g_gl2_dispatch; +} + +const char *getProcName() +{ + static const char *procname = NULL; + + if (procname == NULL) { + const char *str = get_process_name(); + if (strcmp(str, "unknown") != 0) { + procname = str; + } else { + // we need to obtain our process name from the command line; + FILE *fp = fopen("/proc/self/cmdline", "rt"); + if (fp == NULL) { + ALOGE("couldn't open /proc/self/cmdline\n"); + return NULL; + } + + char line[1000]; + if (fgets(line, sizeof(line), fp) == NULL) { + ALOGE("couldn't read the self cmdline from \n"); + fclose(fp); + return NULL; + } + fclose(fp); + + if (line[0] == '\0') { + ALOGE("cmdline is empty\n"); + return NULL; + } + + //obtain the basename; + line[sizeof(line) - 1] = '\0'; + char *p = line; + while (*p != '\0' && + *p != '\t' && + *p != ' ' && + *p != '\n') { + p++; + } + + *p = '\0'; p--; + while (p > line && *p != '/') p--; + if (*p == '/') p++; + procname = strdup(p); + } + } + + return procname; +} + + + +bool isNeedEncode() +{ + const char *procname = getProcName(); + if (procname == NULL) return false; + ALOGD("isNeedEncode? for %s\n", procname); + // check on our whitelist + FILE *fp = fopen(GLES_EMUL_TARGETS_FILE, "rt"); + if (fp == NULL) { + ALOGE("couldn't open %s\n", GLES_EMUL_TARGETS_FILE); + return false; + } + + char line[100]; + bool found = false; + size_t procnameLen = strlen(procname); + + while (fgets(line, sizeof(line), fp) != NULL) { + if (strlen(line) >= procnameLen && + !strncmp(procname, line, procnameLen)) { + char c = line[procnameLen]; + if (c == '\0' || c == ' ' || c == '\t' || c == '\n') { + found = true; + ALOGD("should use encoder for %s\n", procname); + break; + } + } + } + fclose(fp); + return found; +} + +void initDispatchTables() +{ + // + // Load our back-end implementation of EGL/GLES + // + ALOGD("Loading egl dispatch for %s\n", getProcName()); + + void *gles_android = dlopen("/system/lib/egl/libGLES_android.so", RTLD_NOW | RTLD_LOCAL); + if (!gles_android) { + fprintf(stderr,"FATAL ERROR: Could not load libGLES_android lib\n"); + exit(-1); + } + + // + // Load back-end EGL implementation library + // + s_dispatch = create_egl_dispatch( gles_android ); + if (!s_dispatch) { + fprintf(stderr,"FATAL ERROR: Could not create egl dispatch\n"); + exit(-1); + } + + // + // initialize gles + // + s_needEncode = isNeedEncode(); + void *gles_encoder = NULL; + if (s_needEncode) { + // initialize a connection to the server, and the GLESv1/v2 encoders; + ServerConnection * connection = ServerConnection::s_getServerConnection(); + if (connection == NULL) { + ALOGE("couldn't create server connection\n"); + s_needEncode = false; + } + } + + // init dispatch tabels for GLESv1 & GLESv2 + if (s_needEncode) { + // XXX - we do not check the retrun value because there isn't much we can do here on failure. + + if (initApi<gl_wrapper_context_t>(GLESv1_DRIVER, GLESv1_enc_LIB, &g_gl_dispatch, getGLContext) < 0) { + // fallback to android on faluire + s_needEncode = false; + } else { + initApi<gl2_wrapper_context_t>(GLESv2_DRIVER, GLESv2_enc_LIB, &g_gl2_dispatch, getGL2Context); + } + } + + if (!s_needEncode) { + ALOGD("Initializing native opengl for %s\n", getProcName()); + initApi<gl_wrapper_context_t>(GLESv1_DRIVER, GLES_android_LIB, &g_gl_dispatch, getGLContext); + // try to initialize gl2 from GLES, though its probably going to fail + initApi<gl2_wrapper_context_t>(GLESv2_DRIVER, GLES_android_LIB, &g_gl2_dispatch, getGL2Context); + } +} + +static struct egl_dispatch *getDispatch() +{ + pthread_once(&dispatchTablesInitialized, initDispatchTables); + return s_dispatch; +} + +__eglMustCastToProperFunctionPointerType eglGetProcAddress(const char *procname) +{ + + // search in EGL function table + for (int i=0; i<egl_num_funcs; i++) { + if (!strcmp(egl_funcs_by_name[i].name, procname)) { + return (__eglMustCastToProperFunctionPointerType)egl_funcs_by_name[i].proc; + } + } + + // we do not support eglGetProcAddress for GLESv1 & GLESv2. The loader + // should be able to find this function through dynamic loading. + return NULL; +} + +//////////////// Path through functions ////////// + +EGLint eglGetError() +{ + return getDispatch()->eglGetError(); +} + +EGLDisplay eglGetDisplay(EGLNativeDisplayType display_id) +{ + return getDispatch()->eglGetDisplay(display_id); +} + +EGLBoolean eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor) +{ + return getDispatch()->eglInitialize(dpy, major, minor); +} + +EGLBoolean eglTerminate(EGLDisplay dpy) +{ + return getDispatch()->eglTerminate(dpy); +} + +const char* eglQueryString(EGLDisplay dpy, EGLint name) +{ + return getDispatch()->eglQueryString(dpy, name); +} + +EGLBoolean eglGetConfigs(EGLDisplay dpy, EGLConfig *configs, EGLint config_size, EGLint *num_config) +{ + return getDispatch()->eglGetConfigs(dpy, configs, config_size, num_config); +} + +static EGLint * filter_es2_bit(const EGLint *attrib_list, bool *isES2) +{ + if (attrib_list == NULL) { + if (isES2 != NULL) *isES2 = false; + return NULL; + } + + EGLint *attribs = NULL; + int nAttribs = 0; + while(attrib_list[nAttribs] != EGL_NONE) nAttribs++; + nAttribs++; + + attribs = new EGLint[nAttribs]; + memcpy(attribs, attrib_list, nAttribs * sizeof(EGLint)); + if (isES2 != NULL) *isES2 = false; + + // scan the attribute list for ES2 request and replace with ES1. + for (int i = 0; i < nAttribs; i++) { + if (attribs[i] == EGL_RENDERABLE_TYPE) { + if (attribs[i + 1] & EGL_OPENGL_ES2_BIT) { + attribs[i + 1] &= ~EGL_OPENGL_ES2_BIT; + attribs[i + 1] |= EGL_OPENGL_ES_BIT; + ALOGD("removing ES2 bit 0x%x\n", attribs[i + 1]); + if (isES2 != NULL) *isES2 = true; + } + } + } + return attribs; +} + +EGLBoolean eglChooseConfig(EGLDisplay dpy, const EGLint *attrib_list, EGLConfig *configs, EGLint config_size, EGLint *num_config) +{ + EGLBoolean res; + if (s_needEncode) { + EGLint *attribs = filter_es2_bit(attrib_list, NULL); + res = getDispatch()->eglChooseConfig(dpy, + attribs, + configs, + config_size, + num_config); + ALOGD("eglChooseConfig: %d configs found\n", *num_config); + if (*num_config == 0 && attribs != NULL) { + ALOGD("requested attributes:\n"); + for (int i = 0; attribs[i] != EGL_NONE; i++) { + ALOGD("%d: 0x%x\n", i, attribs[i]); + } + } + + delete attribs; + } else { + res = getDispatch()->eglChooseConfig(dpy, attrib_list, configs, config_size, num_config); + } + return res; +} + +EGLBoolean eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config, EGLint attribute, EGLint *value) +{ + if (s_needEncode && attribute == EGL_RENDERABLE_TYPE) { + *value = EGL_OPENGL_ES_BIT | EGL_OPENGL_ES2_BIT; + return EGL_TRUE; + } else { + return getDispatch()->eglGetConfigAttrib(dpy, config, attribute, value); + } +} + +EGLSurface eglCreateWindowSurface(EGLDisplay dpy, EGLConfig config, EGLNativeWindowType win, const EGLint *attrib_list) +{ + EGLSurface surface = getDispatch()->eglCreateWindowSurface(dpy, config, win, attrib_list); + if (surface != EGL_NO_SURFACE) { + ServerConnection *server; + if (s_needEncode && (server = ServerConnection::s_getServerConnection()) != NULL) { + server->utEnc()->createSurface(server->utEnc(), getpid(), (uint32_t)surface); + } + } + return surface; +} + +EGLSurface eglCreatePbufferSurface(EGLDisplay dpy, EGLConfig config, const EGLint *attrib_list) +{ + EGLSurface surface = getDispatch()->eglCreatePbufferSurface(dpy, config, attrib_list); + if (surface != EGL_NO_SURFACE) { + ServerConnection *server; + if (s_needEncode && (server = ServerConnection::s_getServerConnection()) != NULL) { + server->utEnc()->createSurface(server->utEnc(), getpid(), (uint32_t)surface); + } + } + return surface; +} + +EGLSurface eglCreatePixmapSurface(EGLDisplay dpy, EGLConfig config, EGLNativePixmapType pixmap, const EGLint *attrib_list) +{ + EGLSurface surface = getDispatch()->eglCreatePixmapSurface(dpy, config, pixmap, attrib_list); + if (surface != EGL_NO_SURFACE) { + ServerConnection *server; + if (s_needEncode && (server = ServerConnection::s_getServerConnection()) != NULL) { + server->utEnc()->createSurface(server->utEnc(), getpid(), (uint32_t)surface); + } + } + return surface; +} + +EGLBoolean eglDestroySurface(EGLDisplay dpy, EGLSurface surface) +{ + EGLBoolean res = getDispatch()->eglDestroySurface(dpy, surface); + if (res && surface != EGL_NO_SURFACE) { + ServerConnection *server; + if (s_needEncode && (server = ServerConnection::s_getServerConnection()) != NULL) { + server->utEnc()->destroySurface(server->utEnc(), getpid(), (uint32_t)surface); + } + } + return res; +} + +EGLBoolean eglQuerySurface(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint *value) +{ + EGLBoolean res = getDispatch()->eglQuerySurface(dpy, surface, attribute, value); + if (res && attribute == EGL_RENDERABLE_TYPE) { + *value |= EGL_OPENGL_ES2_BIT; + } + return res; +} + +EGLBoolean eglBindAPI(EGLenum api) +{ + return getDispatch()->eglBindAPI(api); +} + +EGLenum eglQueryAPI() +{ + return getDispatch()->eglQueryAPI(); +} + +EGLBoolean eglWaitClient() +{ + return getDispatch()->eglWaitClient(); +} + +EGLBoolean eglReleaseThread() +{ + return getDispatch()->eglReleaseThread(); +} + +EGLSurface eglCreatePbufferFromClientBuffer(EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, EGLConfig config, const EGLint *attrib_list) +{ + return getDispatch()->eglCreatePbufferFromClientBuffer(dpy, buftype, buffer, config, attrib_list); +} + +EGLBoolean eglSurfaceAttrib(EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value) +{ + return getDispatch()->eglSurfaceAttrib(dpy, surface, attribute, value); +} + +EGLBoolean eglBindTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) +{ + return getDispatch()->eglBindTexImage(dpy, surface, buffer); +} + +EGLBoolean eglReleaseTexImage(EGLDisplay dpy, EGLSurface surface, EGLint buffer) +{ + return getDispatch()->eglReleaseTexImage(dpy, surface, buffer); +} + +EGLBoolean eglSwapInterval(EGLDisplay dpy, EGLint interval) +{ + return getDispatch()->eglSwapInterval(dpy, interval); +} + +EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config, EGLContext share_context, const EGLint *attrib_list) +{ + + EGLContext share = share_context; + if (share) share = ((EGLWrapperContext *)share_context)->aglContext; + + // check if are ES2, and convert it to ES1. + int nAttribs = 0; + if (attrib_list != NULL) { + while(attrib_list[nAttribs] != EGL_NONE) { + nAttribs++; + } + nAttribs++; + } + + EGLint *attrib = NULL; + if (nAttribs > 0) { + attrib = new EGLint[nAttribs]; + memcpy(attrib, attrib_list, nAttribs * sizeof(EGLint)); + } + + int version = 1; + for (int i = 0; i < nAttribs; i++) { + if (attrib[i] == EGL_CONTEXT_CLIENT_VERSION && + attrib[i + 1] == 2) { + version = 2; + attrib[i + 1] = 1; // replace to version 1 + } + } + + EGLContext ctx = getDispatch()->eglCreateContext(dpy, config, share, attrib); + delete attrib; + EGLWrapperContext *wctx = new EGLWrapperContext(ctx, version); + if (ctx != EGL_NO_CONTEXT) { + ServerConnection *server; + if (s_needEncode && (server = ServerConnection::s_getServerConnection()) != NULL) { + wctx->clientState = new GLClientState(); + server->utEnc()->createContext(server->utEnc(), getpid(), + (uint32_t)wctx, + (uint32_t)(share_context == EGL_NO_CONTEXT ? 0 : share_context), wctx->version); + } + } + return (EGLContext)wctx; +} + +EGLBoolean eglDestroyContext(EGLDisplay dpy, EGLContext ctx) +{ + EGLWrapperContext *wctx = (EGLWrapperContext *)ctx; + EGLBoolean res = EGL_FALSE; + + if (ctx && ctx != EGL_NO_CONTEXT) { + res = getDispatch()->eglDestroyContext(dpy, wctx->aglContext); + if (res) { + EGLThreadInfo *ti = getEGLThreadInfo(); + ServerConnection *server; + if (s_needEncode && (server = ServerConnection::s_getServerConnection())) { + server->utEnc()->destroyContext(ti->serverConn->utEnc(), getpid(), (uint32_t)ctx); + } + if (ti->currentContext == wctx) ti->currentContext = NULL; + delete wctx; + } + } + + return res; +} + +EGLBoolean eglMakeCurrent(EGLDisplay dpy, EGLSurface draw, EGLSurface read, EGLContext ctx) +{ + EGLWrapperContext *wctx = (EGLWrapperContext *)ctx; + EGLContext aglContext = (ctx == EGL_NO_CONTEXT ? EGL_NO_CONTEXT : wctx->aglContext); + EGLThreadInfo *ti = getEGLThreadInfo(); + EGLBoolean res = getDispatch()->eglMakeCurrent(dpy, draw, read, aglContext); + if (res ) { + // NOTE - we do get a pointer to the server connection, (rather then using ti->serverConn) + // for cases that this is the first egl call of the current thread. + + ServerConnection *server; + if (s_needEncode && (server = ServerConnection::s_getServerConnection())) { + server->utEnc()->makeCurrentContext(server->utEnc(), getpid(), + (uint32_t) (draw == EGL_NO_SURFACE ? 0 : draw), + (uint32_t) (read == EGL_NO_SURFACE ? 0 : read), + (uint32_t) (ctx == EGL_NO_CONTEXT ? 0 : ctx)); + server->glEncoder()->setClientState( wctx ? wctx->clientState : NULL ); + server->gl2Encoder()->setClientState( wctx ? wctx->clientState : NULL ); + } + + // set current context in our thread info + ti->currentContext = wctx; + } + return res; + +} + +EGLContext eglGetCurrentContext() +{ + EGLThreadInfo *ti = getEGLThreadInfo(); + return (ti->currentContext ? ti->currentContext : EGL_NO_CONTEXT); +} + +EGLSurface eglGetCurrentSurface(EGLint readdraw) +{ + return getDispatch()->eglGetCurrentSurface(readdraw); +} + +EGLDisplay eglGetCurrentDisplay() +{ + return getDispatch()->eglGetCurrentDisplay(); +} + +EGLBoolean eglQueryContext(EGLDisplay dpy, EGLContext ctx, EGLint attribute, EGLint *value) +{ + EGLWrapperContext *wctx = (EGLWrapperContext *)ctx; + if (wctx) { + if (attribute == EGL_CONTEXT_CLIENT_VERSION) { + *value = wctx->version; + return EGL_TRUE; + } else { + return getDispatch()->eglQueryContext(dpy, wctx->aglContext, attribute, value); + } + } + else { + return EGL_BAD_CONTEXT; + } +} + +EGLBoolean eglWaitGL() +{ + return getDispatch()->eglWaitGL(); +} + +EGLBoolean eglWaitNative(EGLint engine) +{ + return getDispatch()->eglWaitNative(engine); +} + +EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface surface) +{ + ServerConnection *server; + if (s_needEncode && (server = ServerConnection::s_getServerConnection()) != NULL) { + server->utEnc()->swapBuffers(server->utEnc(), getpid(), (uint32_t)surface); + server->glEncoder()->flush(); + server->gl2Encoder()->flush(); + return 1; + } + return getDispatch()->eglSwapBuffers(dpy, surface); +} + +EGLBoolean eglCopyBuffers(EGLDisplay dpy, EGLSurface surface, EGLNativePixmapType target) +{ + return getDispatch()->eglCopyBuffers(dpy, surface, target); +} + +EGLBoolean eglLockSurfaceKHR(EGLDisplay display, EGLSurface surface, const EGLint *attrib_list) +{ + return getDispatch()->eglLockSurfaceKHR(display, surface, attrib_list); +} + +EGLBoolean eglUnlockSurfaceKHR(EGLDisplay display, EGLSurface surface) +{ + return getDispatch()->eglUnlockSurfaceKHR(display, surface); +} + +EGLImageKHR eglCreateImageKHR(EGLDisplay dpy, EGLContext ctx, EGLenum target, EGLClientBuffer buffer, const EGLint *attrib_list) +{ + EGLWrapperContext *wctx = (EGLWrapperContext *)ctx; + EGLContext aglContext = (wctx ? wctx->aglContext : EGL_NO_CONTEXT); + return getDispatch()->eglCreateImageKHR(dpy, aglContext, target, buffer, attrib_list); +} + +EGLBoolean eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR image) +{ + return getDispatch()->eglDestroyImageKHR(dpy, image); +} + +EGLSyncKHR eglCreateSyncKHR(EGLDisplay dpy, EGLenum type, const EGLint *attrib_list) +{ + return getDispatch()->eglCreateSyncKHR(dpy, type, attrib_list); +} + +EGLBoolean eglDestroySyncKHR(EGLDisplay dpy, EGLSyncKHR sync) +{ + return getDispatch()->eglDestroySyncKHR(dpy, sync); +} + +EGLint eglClientWaitSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint flags, EGLTimeKHR timeout) +{ + return getDispatch()->eglClientWaitSyncKHR(dpy, sync, flags, timeout); +} + +EGLBoolean eglSignalSyncKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLenum mode) +{ + return getDispatch()->eglSignalSyncKHR(dpy, sync, mode); +} + +EGLBoolean eglGetSyncAttribKHR(EGLDisplay dpy, EGLSyncKHR sync, EGLint attribute, EGLint *value) +{ + return getDispatch()->eglGetSyncAttribKHR(dpy, sync, attribute, value); +} + +EGLBoolean eglSetSwapRectangleANDROID(EGLDisplay dpy, EGLSurface draw, EGLint left, EGLint top, EGLint width, EGLint height) +{ + return getDispatch()->eglSetSwapRectangleANDROID(dpy, draw, left, top, width, height); +} diff --git a/emulator/opengl/tests/gles_android_wrapper/egl_dispatch.cpp b/emulator/opengl/tests/gles_android_wrapper/egl_dispatch.cpp new file mode 100644 index 0000000..f69ca61 --- /dev/null +++ b/emulator/opengl/tests/gles_android_wrapper/egl_dispatch.cpp @@ -0,0 +1,71 @@ +/* +* Copyright (C) 2011 The Android Open Source Project +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ +#include <stdio.h> +#include "egl_dispatch.h" +#include <dlfcn.h> + +egl_dispatch *create_egl_dispatch(void *gles_android) +{ + egl_dispatch *disp = new egl_dispatch; + + void *ptr; + ptr = dlsym(gles_android,"eglGetError"); disp->set_eglGetError((eglGetError_t)ptr); + ptr = dlsym(gles_android,"eglGetDisplay"); disp->set_eglGetDisplay((eglGetDisplay_t)ptr); + ptr = dlsym(gles_android,"eglInitialize"); disp->set_eglInitialize((eglInitialize_t)ptr); + ptr = dlsym(gles_android,"eglTerminate"); disp->set_eglTerminate((eglTerminate_t)ptr); + ptr = dlsym(gles_android,"eglQueryString"); disp->set_eglQueryString((eglQueryString_t)ptr); + ptr = dlsym(gles_android,"eglGetConfigs"); disp->set_eglGetConfigs((eglGetConfigs_t)ptr); + ptr = dlsym(gles_android,"eglChooseConfig"); disp->set_eglChooseConfig((eglChooseConfig_t)ptr); + ptr = dlsym(gles_android,"eglGetConfigAttrib"); disp->set_eglGetConfigAttrib((eglGetConfigAttrib_t)ptr); + ptr = dlsym(gles_android,"eglCreateWindowSurface"); disp->set_eglCreateWindowSurface((eglCreateWindowSurface_t)ptr); + ptr = dlsym(gles_android,"eglCreatePbufferSurface"); disp->set_eglCreatePbufferSurface((eglCreatePbufferSurface_t)ptr); + ptr = dlsym(gles_android,"eglCreatePixmapSurface"); disp->set_eglCreatePixmapSurface((eglCreatePixmapSurface_t)ptr); + ptr = dlsym(gles_android,"eglDestroySurface"); disp->set_eglDestroySurface((eglDestroySurface_t)ptr); + ptr = dlsym(gles_android,"eglQuerySurface"); disp->set_eglQuerySurface((eglQuerySurface_t)ptr); + ptr = dlsym(gles_android,"eglBindAPI"); disp->set_eglBindAPI((eglBindAPI_t)ptr); + ptr = dlsym(gles_android,"eglQueryAPI"); disp->set_eglQueryAPI((eglQueryAPI_t)ptr); + ptr = dlsym(gles_android,"eglWaitClient"); disp->set_eglWaitClient((eglWaitClient_t)ptr); + ptr = dlsym(gles_android,"eglReleaseThread"); disp->set_eglReleaseThread((eglReleaseThread_t)ptr); + ptr = dlsym(gles_android,"eglCreatePbufferFromClientBuffer"); disp->set_eglCreatePbufferFromClientBuffer((eglCreatePbufferFromClientBuffer_t)ptr); + ptr = dlsym(gles_android,"eglSurfaceAttrib"); disp->set_eglSurfaceAttrib((eglSurfaceAttrib_t)ptr); + ptr = dlsym(gles_android,"eglBindTexImage"); disp->set_eglBindTexImage((eglBindTexImage_t)ptr); + ptr = dlsym(gles_android,"eglReleaseTexImage"); disp->set_eglReleaseTexImage((eglReleaseTexImage_t)ptr); + ptr = dlsym(gles_android,"eglSwapInterval"); disp->set_eglSwapInterval((eglSwapInterval_t)ptr); + ptr = dlsym(gles_android,"eglCreateContext"); disp->set_eglCreateContext((eglCreateContext_t)ptr); + ptr = dlsym(gles_android,"eglDestroyContext"); disp->set_eglDestroyContext((eglDestroyContext_t)ptr); + ptr = dlsym(gles_android,"eglMakeCurrent"); disp->set_eglMakeCurrent((eglMakeCurrent_t)ptr); + ptr = dlsym(gles_android,"eglGetCurrentContext"); disp->set_eglGetCurrentContext((eglGetCurrentContext_t)ptr); + ptr = dlsym(gles_android,"eglGetCurrentSurface"); disp->set_eglGetCurrentSurface((eglGetCurrentSurface_t)ptr); + ptr = dlsym(gles_android,"eglGetCurrentDisplay"); disp->set_eglGetCurrentDisplay((eglGetCurrentDisplay_t)ptr); + ptr = dlsym(gles_android,"eglQueryContext"); disp->set_eglQueryContext((eglQueryContext_t)ptr); + ptr = dlsym(gles_android,"eglWaitGL"); disp->set_eglWaitGL((eglWaitGL_t)ptr); + ptr = dlsym(gles_android,"eglWaitNative"); disp->set_eglWaitNative((eglWaitNative_t)ptr); + ptr = dlsym(gles_android,"eglSwapBuffers"); disp->set_eglSwapBuffers((eglSwapBuffers_t)ptr); + ptr = dlsym(gles_android,"eglCopyBuffers"); disp->set_eglCopyBuffers((eglCopyBuffers_t)ptr); + ptr = dlsym(gles_android,"eglGetProcAddress"); disp->set_eglGetProcAddress((eglGetProcAddress_t)ptr); + ptr = dlsym(gles_android,"eglLockSurfaceKHR"); disp->set_eglLockSurfaceKHR((eglLockSurfaceKHR_t)ptr); + ptr = dlsym(gles_android,"eglUnlockSurfaceKHR"); disp->set_eglUnlockSurfaceKHR((eglUnlockSurfaceKHR_t)ptr); + ptr = dlsym(gles_android,"eglCreateImageKHR"); disp->set_eglCreateImageKHR((eglCreateImageKHR_t)ptr); + ptr = dlsym(gles_android,"eglDestroyImageKHR"); disp->set_eglDestroyImageKHR((eglDestroyImageKHR_t)ptr); + ptr = dlsym(gles_android,"eglCreateSyncKHR"); disp->set_eglCreateSyncKHR((eglCreateSyncKHR_t)ptr); + ptr = dlsym(gles_android,"eglDestroySyncKHR"); disp->set_eglDestroySyncKHR((eglDestroySyncKHR_t)ptr); + ptr = dlsym(gles_android,"eglClientWaitSyncKHR"); disp->set_eglClientWaitSyncKHR((eglClientWaitSyncKHR_t)ptr); + ptr = dlsym(gles_android,"eglSignalSyncKHR"); disp->set_eglSignalSyncKHR((eglSignalSyncKHR_t)ptr); + ptr = dlsym(gles_android,"eglGetSyncAttribKHR"); disp->set_eglGetSyncAttribKHR((eglGetSyncAttribKHR_t)ptr); + ptr = dlsym(gles_android,"eglSetSwapRectangleANDROID"); disp->set_eglSetSwapRectangleANDROID((eglSetSwapRectangleANDROID_t)ptr); + + return disp; +} diff --git a/emulator/opengl/tests/gles_android_wrapper/egl_dispatch.h b/emulator/opengl/tests/gles_android_wrapper/egl_dispatch.h new file mode 100644 index 0000000..1b8de0d --- /dev/null +++ b/emulator/opengl/tests/gles_android_wrapper/egl_dispatch.h @@ -0,0 +1,115 @@ +/* +* Copyright (C) 2011 The Android Open Source Project +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ +#ifndef _EGL_DISPATCH_H +#define _EGL_DISPATCH_H + +#include "egl_proc.h" + +struct egl_dispatch { + eglGetError_t eglGetError; + eglGetDisplay_t eglGetDisplay; + eglInitialize_t eglInitialize; + eglTerminate_t eglTerminate; + eglQueryString_t eglQueryString; + eglGetConfigs_t eglGetConfigs; + eglChooseConfig_t eglChooseConfig; + eglGetConfigAttrib_t eglGetConfigAttrib; + eglCreateWindowSurface_t eglCreateWindowSurface; + eglCreatePbufferSurface_t eglCreatePbufferSurface; + eglCreatePixmapSurface_t eglCreatePixmapSurface; + eglDestroySurface_t eglDestroySurface; + eglQuerySurface_t eglQuerySurface; + eglBindAPI_t eglBindAPI; + eglQueryAPI_t eglQueryAPI; + eglWaitClient_t eglWaitClient; + eglReleaseThread_t eglReleaseThread; + eglCreatePbufferFromClientBuffer_t eglCreatePbufferFromClientBuffer; + eglSurfaceAttrib_t eglSurfaceAttrib; + eglBindTexImage_t eglBindTexImage; + eglReleaseTexImage_t eglReleaseTexImage; + eglSwapInterval_t eglSwapInterval; + eglCreateContext_t eglCreateContext; + eglDestroyContext_t eglDestroyContext; + eglMakeCurrent_t eglMakeCurrent; + eglGetCurrentContext_t eglGetCurrentContext; + eglGetCurrentSurface_t eglGetCurrentSurface; + eglGetCurrentDisplay_t eglGetCurrentDisplay; + eglQueryContext_t eglQueryContext; + eglWaitGL_t eglWaitGL; + eglWaitNative_t eglWaitNative; + eglSwapBuffers_t eglSwapBuffers; + eglCopyBuffers_t eglCopyBuffers; + eglGetProcAddress_t eglGetProcAddress; + eglLockSurfaceKHR_t eglLockSurfaceKHR; + eglUnlockSurfaceKHR_t eglUnlockSurfaceKHR; + eglCreateImageKHR_t eglCreateImageKHR; + eglDestroyImageKHR_t eglDestroyImageKHR; + eglCreateSyncKHR_t eglCreateSyncKHR; + eglDestroySyncKHR_t eglDestroySyncKHR; + eglClientWaitSyncKHR_t eglClientWaitSyncKHR; + eglSignalSyncKHR_t eglSignalSyncKHR; + eglGetSyncAttribKHR_t eglGetSyncAttribKHR; + eglSetSwapRectangleANDROID_t eglSetSwapRectangleANDROID; + //Accessors + eglGetError_t set_eglGetError(eglGetError_t f) { eglGetError_t retval = eglGetError; eglGetError = f; return retval;} + eglGetDisplay_t set_eglGetDisplay(eglGetDisplay_t f) { eglGetDisplay_t retval = eglGetDisplay; eglGetDisplay = f; return retval;} + eglInitialize_t set_eglInitialize(eglInitialize_t f) { eglInitialize_t retval = eglInitialize; eglInitialize = f; return retval;} + eglTerminate_t set_eglTerminate(eglTerminate_t f) { eglTerminate_t retval = eglTerminate; eglTerminate = f; return retval;} + eglQueryString_t set_eglQueryString(eglQueryString_t f) { eglQueryString_t retval = eglQueryString; eglQueryString = f; return retval;} + eglGetConfigs_t set_eglGetConfigs(eglGetConfigs_t f) { eglGetConfigs_t retval = eglGetConfigs; eglGetConfigs = f; return retval;} + eglChooseConfig_t set_eglChooseConfig(eglChooseConfig_t f) { eglChooseConfig_t retval = eglChooseConfig; eglChooseConfig = f; return retval;} + eglGetConfigAttrib_t set_eglGetConfigAttrib(eglGetConfigAttrib_t f) { eglGetConfigAttrib_t retval = eglGetConfigAttrib; eglGetConfigAttrib = f; return retval;} + eglCreateWindowSurface_t set_eglCreateWindowSurface(eglCreateWindowSurface_t f) { eglCreateWindowSurface_t retval = eglCreateWindowSurface; eglCreateWindowSurface = f; return retval;} + eglCreatePbufferSurface_t set_eglCreatePbufferSurface(eglCreatePbufferSurface_t f) { eglCreatePbufferSurface_t retval = eglCreatePbufferSurface; eglCreatePbufferSurface = f; return retval;} + eglCreatePixmapSurface_t set_eglCreatePixmapSurface(eglCreatePixmapSurface_t f) { eglCreatePixmapSurface_t retval = eglCreatePixmapSurface; eglCreatePixmapSurface = f; return retval;} + eglDestroySurface_t set_eglDestroySurface(eglDestroySurface_t f) { eglDestroySurface_t retval = eglDestroySurface; eglDestroySurface = f; return retval;} + eglQuerySurface_t set_eglQuerySurface(eglQuerySurface_t f) { eglQuerySurface_t retval = eglQuerySurface; eglQuerySurface = f; return retval;} + eglBindAPI_t set_eglBindAPI(eglBindAPI_t f) { eglBindAPI_t retval = eglBindAPI; eglBindAPI = f; return retval;} + eglQueryAPI_t set_eglQueryAPI(eglQueryAPI_t f) { eglQueryAPI_t retval = eglQueryAPI; eglQueryAPI = f; return retval;} + eglWaitClient_t set_eglWaitClient(eglWaitClient_t f) { eglWaitClient_t retval = eglWaitClient; eglWaitClient = f; return retval;} + eglReleaseThread_t set_eglReleaseThread(eglReleaseThread_t f) { eglReleaseThread_t retval = eglReleaseThread; eglReleaseThread = f; return retval;} + eglCreatePbufferFromClientBuffer_t set_eglCreatePbufferFromClientBuffer(eglCreatePbufferFromClientBuffer_t f) { eglCreatePbufferFromClientBuffer_t retval = eglCreatePbufferFromClientBuffer; eglCreatePbufferFromClientBuffer = f; return retval;} + eglSurfaceAttrib_t set_eglSurfaceAttrib(eglSurfaceAttrib_t f) { eglSurfaceAttrib_t retval = eglSurfaceAttrib; eglSurfaceAttrib = f; return retval;} + eglBindTexImage_t set_eglBindTexImage(eglBindTexImage_t f) { eglBindTexImage_t retval = eglBindTexImage; eglBindTexImage = f; return retval;} + eglReleaseTexImage_t set_eglReleaseTexImage(eglReleaseTexImage_t f) { eglReleaseTexImage_t retval = eglReleaseTexImage; eglReleaseTexImage = f; return retval;} + eglSwapInterval_t set_eglSwapInterval(eglSwapInterval_t f) { eglSwapInterval_t retval = eglSwapInterval; eglSwapInterval = f; return retval;} + eglCreateContext_t set_eglCreateContext(eglCreateContext_t f) { eglCreateContext_t retval = eglCreateContext; eglCreateContext = f; return retval;} + eglDestroyContext_t set_eglDestroyContext(eglDestroyContext_t f) { eglDestroyContext_t retval = eglDestroyContext; eglDestroyContext = f; return retval;} + eglMakeCurrent_t set_eglMakeCurrent(eglMakeCurrent_t f) { eglMakeCurrent_t retval = eglMakeCurrent; eglMakeCurrent = f; return retval;} + eglGetCurrentContext_t set_eglGetCurrentContext(eglGetCurrentContext_t f) { eglGetCurrentContext_t retval = eglGetCurrentContext; eglGetCurrentContext = f; return retval;} + eglGetCurrentSurface_t set_eglGetCurrentSurface(eglGetCurrentSurface_t f) { eglGetCurrentSurface_t retval = eglGetCurrentSurface; eglGetCurrentSurface = f; return retval;} + eglGetCurrentDisplay_t set_eglGetCurrentDisplay(eglGetCurrentDisplay_t f) { eglGetCurrentDisplay_t retval = eglGetCurrentDisplay; eglGetCurrentDisplay = f; return retval;} + eglQueryContext_t set_eglQueryContext(eglQueryContext_t f) { eglQueryContext_t retval = eglQueryContext; eglQueryContext = f; return retval;} + eglWaitGL_t set_eglWaitGL(eglWaitGL_t f) { eglWaitGL_t retval = eglWaitGL; eglWaitGL = f; return retval;} + eglWaitNative_t set_eglWaitNative(eglWaitNative_t f) { eglWaitNative_t retval = eglWaitNative; eglWaitNative = f; return retval;} + eglSwapBuffers_t set_eglSwapBuffers(eglSwapBuffers_t f) { eglSwapBuffers_t retval = eglSwapBuffers; eglSwapBuffers = f; return retval;} + eglCopyBuffers_t set_eglCopyBuffers(eglCopyBuffers_t f) { eglCopyBuffers_t retval = eglCopyBuffers; eglCopyBuffers = f; return retval;} + eglGetProcAddress_t set_eglGetProcAddress(eglGetProcAddress_t f) { eglGetProcAddress_t retval = eglGetProcAddress; eglGetProcAddress = f; return retval;} + eglLockSurfaceKHR_t set_eglLockSurfaceKHR(eglLockSurfaceKHR_t f) { eglLockSurfaceKHR_t retval = eglLockSurfaceKHR; eglLockSurfaceKHR = f; return retval;} + eglUnlockSurfaceKHR_t set_eglUnlockSurfaceKHR(eglUnlockSurfaceKHR_t f) { eglUnlockSurfaceKHR_t retval = eglUnlockSurfaceKHR; eglUnlockSurfaceKHR = f; return retval;} + eglCreateImageKHR_t set_eglCreateImageKHR(eglCreateImageKHR_t f) { eglCreateImageKHR_t retval = eglCreateImageKHR; eglCreateImageKHR = f; return retval;} + eglDestroyImageKHR_t set_eglDestroyImageKHR(eglDestroyImageKHR_t f) { eglDestroyImageKHR_t retval = eglDestroyImageKHR; eglDestroyImageKHR = f; return retval;} + eglCreateSyncKHR_t set_eglCreateSyncKHR(eglCreateSyncKHR_t f) { eglCreateSyncKHR_t retval = eglCreateSyncKHR; eglCreateSyncKHR = f; return retval;} + eglDestroySyncKHR_t set_eglDestroySyncKHR(eglDestroySyncKHR_t f) { eglDestroySyncKHR_t retval = eglDestroySyncKHR; eglDestroySyncKHR = f; return retval;} + eglClientWaitSyncKHR_t set_eglClientWaitSyncKHR(eglClientWaitSyncKHR_t f) { eglClientWaitSyncKHR_t retval = eglClientWaitSyncKHR; eglClientWaitSyncKHR = f; return retval;} + eglSignalSyncKHR_t set_eglSignalSyncKHR(eglSignalSyncKHR_t f) { eglSignalSyncKHR_t retval = eglSignalSyncKHR; eglSignalSyncKHR = f; return retval;} + eglGetSyncAttribKHR_t set_eglGetSyncAttribKHR(eglGetSyncAttribKHR_t f) { eglGetSyncAttribKHR_t retval = eglGetSyncAttribKHR; eglGetSyncAttribKHR = f; return retval;} + eglSetSwapRectangleANDROID_t set_eglSetSwapRectangleANDROID(eglSetSwapRectangleANDROID_t f) { eglSetSwapRectangleANDROID_t retval = eglSetSwapRectangleANDROID; eglSetSwapRectangleANDROID = f; return retval;} +}; + +egl_dispatch *create_egl_dispatch(void *gles_andorid); + +#endif diff --git a/emulator/opengl/tests/gles_android_wrapper/egl_ftable.h b/emulator/opengl/tests/gles_android_wrapper/egl_ftable.h new file mode 100644 index 0000000..ee40585 --- /dev/null +++ b/emulator/opengl/tests/gles_android_wrapper/egl_ftable.h @@ -0,0 +1,66 @@ +/* +* Copyright (C) 2011 The Android Open Source Project +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ +static struct _egl_funcs_by_name { + const char *name; + void *proc; +} egl_funcs_by_name[] = { + {"eglGetError", (void *)eglGetError}, + {"eglGetDisplay", (void *)eglGetDisplay}, + {"eglInitialize", (void *)eglInitialize}, + {"eglTerminate", (void *)eglTerminate}, + {"eglQueryString", (void *)eglQueryString}, + {"eglGetConfigs", (void *)eglGetConfigs}, + {"eglChooseConfig", (void *)eglChooseConfig}, + {"eglGetConfigAttrib", (void *)eglGetConfigAttrib}, + {"eglCreateWindowSurface", (void *)eglCreateWindowSurface}, + {"eglCreatePbufferSurface", (void *)eglCreatePbufferSurface}, + {"eglCreatePixmapSurface", (void *)eglCreatePixmapSurface}, + {"eglDestroySurface", (void *)eglDestroySurface}, + {"eglQuerySurface", (void *)eglQuerySurface}, + {"eglBindAPI", (void *)eglBindAPI}, + {"eglQueryAPI", (void *)eglQueryAPI}, + {"eglWaitClient", (void *)eglWaitClient}, + {"eglReleaseThread", (void *)eglReleaseThread}, + {"eglCreatePbufferFromClientBuffer", (void *)eglCreatePbufferFromClientBuffer}, + {"eglSurfaceAttrib", (void *)eglSurfaceAttrib}, + {"eglBindTexImage", (void *)eglBindTexImage}, + {"eglReleaseTexImage", (void *)eglReleaseTexImage}, + {"eglSwapInterval", (void *)eglSwapInterval}, + {"eglCreateContext", (void *)eglCreateContext}, + {"eglDestroyContext", (void *)eglDestroyContext}, + {"eglMakeCurrent", (void *)eglMakeCurrent}, + {"eglGetCurrentContext", (void *)eglGetCurrentContext}, + {"eglGetCurrentSurface", (void *)eglGetCurrentSurface}, + {"eglGetCurrentDisplay", (void *)eglGetCurrentDisplay}, + {"eglQueryContext", (void *)eglQueryContext}, + {"eglWaitGL", (void *)eglWaitGL}, + {"eglWaitNative", (void *)eglWaitNative}, + {"eglSwapBuffers", (void *)eglSwapBuffers}, + {"eglCopyBuffers", (void *)eglCopyBuffers}, + {"eglGetProcAddress", (void *)eglGetProcAddress}, + {"eglLockSurfaceKHR", (void *)eglLockSurfaceKHR}, + {"eglUnlockSurfaceKHR", (void *)eglUnlockSurfaceKHR}, + {"eglCreateImageKHR", (void *)eglCreateImageKHR}, + {"eglDestroyImageKHR", (void *)eglDestroyImageKHR}, + {"eglCreateSyncKHR", (void *)eglCreateSyncKHR}, + {"eglDestroySyncKHR", (void *)eglDestroySyncKHR}, + {"eglClientWaitSyncKHR", (void *)eglClientWaitSyncKHR}, + {"eglSignalSyncKHR", (void *)eglSignalSyncKHR}, + {"eglGetSyncAttribKHR", (void *)eglGetSyncAttribKHR}, + {"eglSetSwapRectangleANDROID", (void *)eglSetSwapRectangleANDROID} +}; + +static int egl_num_funcs = sizeof(egl_funcs_by_name) / sizeof(struct _egl_funcs_by_name); diff --git a/emulator/opengl/tests/gles_android_wrapper/egl_proc.h b/emulator/opengl/tests/gles_android_wrapper/egl_proc.h new file mode 100644 index 0000000..140c030 --- /dev/null +++ b/emulator/opengl/tests/gles_android_wrapper/egl_proc.h @@ -0,0 +1,68 @@ +/* +* Copyright (C) 2011 The Android Open Source Project +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ +#ifndef _EGL_PROC_H +#define _EGL_PROC_H + +#include <EGL/egl.h> +#define EGL_EGLEXT_PROTOTYPES +#include <EGL/eglext.h> + +typedef EGLint (* eglGetError_t) (); +typedef EGLDisplay (* eglGetDisplay_t) (EGLNativeDisplayType); +typedef EGLBoolean (* eglInitialize_t) (EGLDisplay, EGLint*, EGLint*); +typedef EGLBoolean (* eglTerminate_t) (EGLDisplay); +typedef char* (* eglQueryString_t) (EGLDisplay, EGLint); +typedef EGLBoolean (* eglGetConfigs_t) (EGLDisplay, EGLConfig*, EGLint, EGLint*); +typedef EGLBoolean (* eglChooseConfig_t) (EGLDisplay, const EGLint*, EGLConfig*, EGLint, EGLint*); +typedef EGLBoolean (* eglGetConfigAttrib_t) (EGLDisplay, EGLConfig, EGLint, EGLint*); +typedef EGLSurface (* eglCreateWindowSurface_t) (EGLDisplay, EGLConfig, EGLNativeWindowType, const EGLint*); +typedef EGLSurface (* eglCreatePbufferSurface_t) (EGLDisplay, EGLConfig, const EGLint*); +typedef EGLSurface (* eglCreatePixmapSurface_t) (EGLDisplay, EGLConfig, EGLNativePixmapType, const EGLint*); +typedef EGLBoolean (* eglDestroySurface_t) (EGLDisplay, EGLSurface); +typedef EGLBoolean (* eglQuerySurface_t) (EGLDisplay, EGLSurface, EGLint, EGLint*); +typedef EGLBoolean (* eglBindAPI_t) (EGLenum); +typedef EGLenum (* eglQueryAPI_t) (); +typedef EGLBoolean (* eglWaitClient_t) (); +typedef EGLBoolean (* eglReleaseThread_t) (); +typedef EGLSurface (* eglCreatePbufferFromClientBuffer_t) (EGLDisplay, EGLenum, EGLClientBuffer, EGLConfig, const EGLint*); +typedef EGLBoolean (* eglSurfaceAttrib_t) (EGLDisplay, EGLSurface, EGLint, EGLint); +typedef EGLBoolean (* eglBindTexImage_t) (EGLDisplay, EGLSurface, EGLint); +typedef EGLBoolean (* eglReleaseTexImage_t) (EGLDisplay, EGLSurface, EGLint); +typedef EGLBoolean (* eglSwapInterval_t) (EGLDisplay, EGLint); +typedef EGLContext (* eglCreateContext_t) (EGLDisplay, EGLConfig, EGLContext, const EGLint*); +typedef EGLBoolean (* eglDestroyContext_t) (EGLDisplay, EGLContext); +typedef EGLBoolean (* eglMakeCurrent_t) (EGLDisplay, EGLSurface, EGLSurface, EGLContext); +typedef EGLContext (* eglGetCurrentContext_t) (); +typedef EGLSurface (* eglGetCurrentSurface_t) (EGLint); +typedef EGLDisplay (* eglGetCurrentDisplay_t) (); +typedef EGLBoolean (* eglQueryContext_t) (EGLDisplay, EGLContext, EGLint, EGLint*); +typedef EGLBoolean (* eglWaitGL_t) (); +typedef EGLBoolean (* eglWaitNative_t) (EGLint); +typedef EGLBoolean (* eglSwapBuffers_t) (EGLDisplay, EGLSurface); +typedef EGLBoolean (* eglCopyBuffers_t) (EGLDisplay, EGLSurface, EGLNativePixmapType); +typedef __eglMustCastToProperFunctionPointerType (* eglGetProcAddress_t) (const char*); +typedef EGLBoolean (* eglLockSurfaceKHR_t) (EGLDisplay, EGLSurface, const EGLint*); +typedef EGLBoolean (* eglUnlockSurfaceKHR_t) (EGLDisplay, EGLSurface); +typedef EGLImageKHR (* eglCreateImageKHR_t) (EGLDisplay, EGLContext, EGLenum, EGLClientBuffer, const EGLint*); +typedef EGLBoolean (* eglDestroyImageKHR_t) (EGLDisplay, EGLImageKHR image); +typedef EGLSyncKHR (* eglCreateSyncKHR_t) (EGLDisplay, EGLenum, const EGLint*); +typedef EGLBoolean (* eglDestroySyncKHR_t) (EGLDisplay, EGLSyncKHR sync); +typedef EGLint (* eglClientWaitSyncKHR_t) (EGLDisplay, EGLSyncKHR, EGLint, EGLTimeKHR timeout); +typedef EGLBoolean (* eglSignalSyncKHR_t) (EGLDisplay, EGLSyncKHR, EGLenum); +typedef EGLBoolean (* eglGetSyncAttribKHR_t) (EGLDisplay, EGLSyncKHR, EGLint, EGLint*); +typedef EGLBoolean (* eglSetSwapRectangleANDROID_t) (EGLDisplay, EGLSurface, EGLint, EGLint, EGLint, EGLint); + +#endif // of _EGL_PROC_H diff --git a/emulator/opengl/tests/gles_android_wrapper/gles.cpp b/emulator/opengl/tests/gles_android_wrapper/gles.cpp new file mode 100644 index 0000000..c0949c8 --- /dev/null +++ b/emulator/opengl/tests/gles_android_wrapper/gles.cpp @@ -0,0 +1,1410 @@ +/* +* Copyright (C) 2011 The Android Open Source Project +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ +#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include "gles_dispatch.h" +#include "gles_ftable.h" +#include <EGL/egl.h> +#include <cutils/log.h> + +static struct gles_dispatch *s_dispatch = NULL; + +void init_gles(void *gles_android) +{ + s_dispatch = create_gles_dispatch(gles_android); + if (s_dispatch == NULL) { + ALOGE("failed to create gles dispatch\n"); + } +} + +static struct gles_dispatch *getDispatch() +{ + if (!s_dispatch) { + fprintf(stderr,"FATAL ERROR: GLES has not been initialized\n"); + exit(-1); + } + + return s_dispatch; +} + +__eglMustCastToProperFunctionPointerType gles_getProcAddress(const char *procname) +{ + for (int i=0; i<gles_num_funcs; i++) { + if (!strcmp(gles_funcs_by_name[i].name, procname)) { + return (__eglMustCastToProperFunctionPointerType)gles_funcs_by_name[i].proc; + } + } + + return NULL; +} + +///////////// Path-through functions /////////////// +void glAlphaFunc(GLenum func, GLclampf ref) +{ + getDispatch()->glAlphaFunc(func, ref); +} + +void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) +{ + getDispatch()->glClearColor(red, green, blue, alpha); +} + +void glClearDepthf(GLclampf depth) +{ + getDispatch()->glClearDepthf(depth); +} + +void glClipPlanef(GLenum plane, const GLfloat *equation) +{ + getDispatch()->glClipPlanef(plane, equation); +} + +void glColor4f(GLfloat red, GLfloat green, GLfloat blue, GLfloat alpha) +{ + getDispatch()->glColor4f(red, green, blue, alpha); +} + +void glDepthRangef(GLclampf zNear, GLclampf zFar) +{ + getDispatch()->glDepthRangef(zNear, zFar); +} + +void glFogf(GLenum pname, GLfloat param) +{ + getDispatch()->glFogf(pname, param); +} + +void glFogfv(GLenum pname, const GLfloat *params) +{ + getDispatch()->glFogfv(pname, params); +} + +void glFrustumf(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) +{ + getDispatch()->glFrustumf(left, right, bottom, top, zNear, zFar); +} + +void glGetClipPlanef(GLenum pname, GLfloat eqn[4]) +{ + getDispatch()->glGetClipPlanef(pname, eqn); +} + +void glGetFloatv(GLenum pname, GLfloat *params) +{ + getDispatch()->glGetFloatv(pname, params); +} + +void glGetLightfv(GLenum light, GLenum pname, GLfloat *params) +{ + getDispatch()->glGetLightfv(light, pname, params); +} + +void glGetMaterialfv(GLenum face, GLenum pname, GLfloat *params) +{ + getDispatch()->glGetMaterialfv(face, pname, params); +} + +void glGetTexEnvfv(GLenum env, GLenum pname, GLfloat *params) +{ + getDispatch()->glGetTexEnvfv(env, pname, params); +} + +void glGetTexParameterfv(GLenum target, GLenum pname, GLfloat *params) +{ + getDispatch()->glGetTexParameterfv(target, pname, params); +} + +void glLightModelf(GLenum pname, GLfloat param) +{ + getDispatch()->glLightModelf(pname, param); +} + +void glLightModelfv(GLenum pname, const GLfloat *params) +{ + getDispatch()->glLightModelfv(pname, params); +} + +void glLightf(GLenum light, GLenum pname, GLfloat param) +{ + getDispatch()->glLightf(light, pname, param); +} + +void glLightfv(GLenum light, GLenum pname, const GLfloat *params) +{ + getDispatch()->glLightfv(light, pname, params); +} + +void glLineWidth(GLfloat width) +{ + getDispatch()->glLineWidth(width); +} + +void glLoadMatrixf(const GLfloat *m) +{ + getDispatch()->glLoadMatrixf(m); +} + +void glMaterialf(GLenum face, GLenum pname, GLfloat param) +{ + getDispatch()->glMaterialf(face, pname, param); +} + +void glMaterialfv(GLenum face, GLenum pname, const GLfloat *params) +{ + getDispatch()->glMaterialfv(face, pname, params); +} + +void glMultMatrixf(const GLfloat *m) +{ + getDispatch()->glMultMatrixf(m); +} + +void glMultiTexCoord4f(GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q) +{ + getDispatch()->glMultiTexCoord4f(target, s, t, r, q); +} + +void glNormal3f(GLfloat nx, GLfloat ny, GLfloat nz) +{ + getDispatch()->glNormal3f(nx, ny, nz); +} + +void glOrthof(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) +{ + getDispatch()->glOrthof(left, right, bottom, top, zNear, zFar); +} + +void glPointParameterf(GLenum pname, GLfloat param) +{ + getDispatch()->glPointParameterf(pname, param); +} + +void glPointParameterfv(GLenum pname, const GLfloat *params) +{ + getDispatch()->glPointParameterfv(pname, params); +} + +void glPointSize(GLfloat size) +{ + getDispatch()->glPointSize(size); +} + +void glPolygonOffset(GLfloat factor, GLfloat units) +{ + getDispatch()->glPolygonOffset(factor, units); +} + +void glRotatef(GLfloat angle, GLfloat x, GLfloat y, GLfloat z) +{ + getDispatch()->glRotatef(angle, x, y, z); +} + +void glScalef(GLfloat x, GLfloat y, GLfloat z) +{ + getDispatch()->glScalef(x, y, z); +} + +void glTexEnvf(GLenum target, GLenum pname, GLfloat param) +{ + getDispatch()->glTexEnvf(target, pname, param); +} + +void glTexEnvfv(GLenum target, GLenum pname, const GLfloat *params) +{ + getDispatch()->glTexEnvfv(target, pname, params); +} + +void glTexParameterf(GLenum target, GLenum pname, GLfloat param) +{ + getDispatch()->glTexParameterf(target, pname, param); +} + +void glTexParameterfv(GLenum target, GLenum pname, const GLfloat *params) +{ + getDispatch()->glTexParameterfv(target, pname, params); +} + +void glTranslatef(GLfloat x, GLfloat y, GLfloat z) +{ + getDispatch()->glTranslatef(x, y, z); +} + +void glActiveTexture(GLenum texture) +{ + getDispatch()->glActiveTexture(texture); +} + +void glAlphaFuncx(GLenum func, GLclampx ref) +{ + getDispatch()->glAlphaFuncx(func, ref); +} + +void glBindBuffer(GLenum target, GLuint buffer) +{ + getDispatch()->glBindBuffer(target, buffer); +} + +void glBindTexture(GLenum target, GLuint texture) +{ + getDispatch()->glBindTexture(target, texture); +} + +void glBlendFunc(GLenum sfactor, GLenum dfactor) +{ + getDispatch()->glBlendFunc(sfactor, dfactor); +} + +void glBufferData(GLenum target, GLsizeiptr size, const GLvoid *data, GLenum usage) +{ + getDispatch()->glBufferData(target, size, data, usage); +} + +void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid *data) +{ + getDispatch()->glBufferSubData(target, offset, size, data); +} + +void glClear(GLbitfield mask) +{ + getDispatch()->glClear(mask); +} + +void glClearColorx(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha) +{ + getDispatch()->glClearColorx(red, green, blue, alpha); +} + +void glClearDepthx(GLclampx depth) +{ + getDispatch()->glClearDepthx(depth); +} + +void glClearStencil(GLint s) +{ + getDispatch()->glClearStencil(s); +} + +void glClientActiveTexture(GLenum texture) +{ + getDispatch()->glClientActiveTexture(texture); +} + +void glClipPlanex(GLenum plane, const GLfixed *equation) +{ + getDispatch()->glClipPlanex(plane, equation); +} + +void glColor4ub(GLubyte red, GLubyte green, GLubyte blue, GLubyte alpha) +{ + getDispatch()->glColor4ub(red, green, blue, alpha); +} + +void glColor4x(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha) +{ + getDispatch()->glColor4x(red, green, blue, alpha); +} + +void glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) +{ + getDispatch()->glColorMask(red, green, blue, alpha); +} + +void glColorPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) +{ + getDispatch()->glColorPointer(size, type, stride, pointer); +} + +void glCompressedTexImage2D(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid *data) +{ + getDispatch()->glCompressedTexImage2D(target, level, internalformat, width, height, border, imageSize, data); +} + +void glCompressedTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid *data) +{ + getDispatch()->glCompressedTexSubImage2D(target, level, xoffset, yoffset, width, height, format, imageSize, data); +} + +void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, GLint x, GLint y, GLsizei width, GLsizei height, GLint border) +{ + getDispatch()->glCopyTexImage2D(target, level, internalformat, x, y, width, height, border); +} + +void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + getDispatch()->glCopyTexSubImage2D(target, level, xoffset, yoffset, x, y, width, height); +} + +void glCullFace(GLenum mode) +{ + getDispatch()->glCullFace(mode); +} + +void glDeleteBuffers(GLsizei n, const GLuint *buffers) +{ + getDispatch()->glDeleteBuffers(n, buffers); +} + +void glDeleteTextures(GLsizei n, const GLuint *textures) +{ + getDispatch()->glDeleteTextures(n, textures); +} + +void glDepthFunc(GLenum func) +{ + getDispatch()->glDepthFunc(func); +} + +void glDepthMask(GLboolean flag) +{ + getDispatch()->glDepthMask(flag); +} + +void glDepthRangex(GLclampx zNear, GLclampx zFar) +{ + getDispatch()->glDepthRangex(zNear, zFar); +} + +void glDisable(GLenum cap) +{ + getDispatch()->glDisable(cap); +} + +void glDisableClientState(GLenum array) +{ + getDispatch()->glDisableClientState(array); +} + +void glDrawArrays(GLenum mode, GLint first, GLsizei count) +{ + getDispatch()->glDrawArrays(mode, first, count); +} + +void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid *indices) +{ + getDispatch()->glDrawElements(mode, count, type, indices); +} + +void glEnable(GLenum cap) +{ + getDispatch()->glEnable(cap); +} + +void glEnableClientState(GLenum array) +{ + getDispatch()->glEnableClientState(array); +} + +void glFinish() +{ + getDispatch()->glFinish(); +} + +void glFlush() +{ + getDispatch()->glFlush(); +} + +void glFogx(GLenum pname, GLfixed param) +{ + getDispatch()->glFogx(pname, param); +} + +void glFogxv(GLenum pname, const GLfixed *params) +{ + getDispatch()->glFogxv(pname, params); +} + +void glFrontFace(GLenum mode) +{ + getDispatch()->glFrontFace(mode); +} + +void glFrustumx(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) +{ + getDispatch()->glFrustumx(left, right, bottom, top, zNear, zFar); +} + +void glGetBooleanv(GLenum pname, GLboolean *params) +{ + getDispatch()->glGetBooleanv(pname, params); +} + +void glGetBufferParameteriv(GLenum target, GLenum pname, GLint *params) +{ + getDispatch()->glGetBufferParameteriv(target, pname, params); +} + +void glGetClipPlanex(GLenum pname, GLfixed eqn[4]) +{ + getDispatch()->glGetClipPlanex(pname, eqn); +} + +void glGenBuffers(GLsizei n, GLuint *buffers) +{ + getDispatch()->glGenBuffers(n, buffers); +} + +void glGenTextures(GLsizei n, GLuint *textures) +{ + getDispatch()->glGenTextures(n, textures); +} + +GLenum glGetError() +{ + return getDispatch()->glGetError(); +} + +void glGetFixedv(GLenum pname, GLfixed *params) +{ + getDispatch()->glGetFixedv(pname, params); +} + +void glGetIntegerv(GLenum pname, GLint *params) +{ + getDispatch()->glGetIntegerv(pname, params); +} + +void glGetLightxv(GLenum light, GLenum pname, GLfixed *params) +{ + getDispatch()->glGetLightxv(light, pname, params); +} + +void glGetMaterialxv(GLenum face, GLenum pname, GLfixed *params) +{ + getDispatch()->glGetMaterialxv(face, pname, params); +} + +void glGetPointerv(GLenum pname, GLvoid **params) +{ + getDispatch()->glGetPointerv(pname, params); +} + +const GLubyte* glGetString(GLenum name) +{ + return getDispatch()->glGetString(name); +} + +void glGetTexEnviv(GLenum env, GLenum pname, GLint *params) +{ + getDispatch()->glGetTexEnviv(env, pname, params); +} + +void glGetTexEnvxv(GLenum env, GLenum pname, GLfixed *params) +{ + getDispatch()->glGetTexEnvxv(env, pname, params); +} + +void glGetTexParameteriv(GLenum target, GLenum pname, GLint *params) +{ + getDispatch()->glGetTexParameteriv(target, pname, params); +} + +void glGetTexParameterxv(GLenum target, GLenum pname, GLfixed *params) +{ + getDispatch()->glGetTexParameterxv(target, pname, params); +} + +void glHint(GLenum target, GLenum mode) +{ + getDispatch()->glHint(target, mode); +} + +GLboolean glIsBuffer(GLuint buffer) +{ + return getDispatch()->glIsBuffer(buffer); +} + +GLboolean glIsEnabled(GLenum cap) +{ + return getDispatch()->glIsEnabled(cap); +} + +GLboolean glIsTexture(GLuint texture) +{ + return getDispatch()->glIsTexture(texture); +} + +void glLightModelx(GLenum pname, GLfixed param) +{ + getDispatch()->glLightModelx(pname, param); +} + +void glLightModelxv(GLenum pname, const GLfixed *params) +{ + getDispatch()->glLightModelxv(pname, params); +} + +void glLightx(GLenum light, GLenum pname, GLfixed param) +{ + getDispatch()->glLightx(light, pname, param); +} + +void glLightxv(GLenum light, GLenum pname, const GLfixed *params) +{ + getDispatch()->glLightxv(light, pname, params); +} + +void glLineWidthx(GLfixed width) +{ + getDispatch()->glLineWidthx(width); +} + +void glLoadIdentity() +{ + getDispatch()->glLoadIdentity(); +} + +void glLoadMatrixx(const GLfixed *m) +{ + getDispatch()->glLoadMatrixx(m); +} + +void glLogicOp(GLenum opcode) +{ + getDispatch()->glLogicOp(opcode); +} + +void glMaterialx(GLenum face, GLenum pname, GLfixed param) +{ + getDispatch()->glMaterialx(face, pname, param); +} + +void glMaterialxv(GLenum face, GLenum pname, const GLfixed *params) +{ + getDispatch()->glMaterialxv(face, pname, params); +} + +void glMatrixMode(GLenum mode) +{ + getDispatch()->glMatrixMode(mode); +} + +void glMultMatrixx(const GLfixed *m) +{ + getDispatch()->glMultMatrixx(m); +} + +void glMultiTexCoord4x(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q) +{ + getDispatch()->glMultiTexCoord4x(target, s, t, r, q); +} + +void glNormal3x(GLfixed nx, GLfixed ny, GLfixed nz) +{ + getDispatch()->glNormal3x(nx, ny, nz); +} + +void glNormalPointer(GLenum type, GLsizei stride, const GLvoid *pointer) +{ + getDispatch()->glNormalPointer(type, stride, pointer); +} + +void glOrthox(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) +{ + getDispatch()->glOrthox(left, right, bottom, top, zNear, zFar); +} + +void glPixelStorei(GLenum pname, GLint param) +{ + getDispatch()->glPixelStorei(pname, param); +} + +void glPointParameterx(GLenum pname, GLfixed param) +{ + getDispatch()->glPointParameterx(pname, param); +} + +void glPointParameterxv(GLenum pname, const GLfixed *params) +{ + getDispatch()->glPointParameterxv(pname, params); +} + +void glPointSizex(GLfixed size) +{ + getDispatch()->glPointSizex(size); +} + +void glPolygonOffsetx(GLfixed factor, GLfixed units) +{ + getDispatch()->glPolygonOffsetx(factor, units); +} + +void glPopMatrix() +{ + getDispatch()->glPopMatrix(); +} + +void glPushMatrix() +{ + getDispatch()->glPushMatrix(); +} + +void glReadPixels(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid *pixels) +{ + getDispatch()->glReadPixels(x, y, width, height, format, type, pixels); +} + +void glRotatex(GLfixed angle, GLfixed x, GLfixed y, GLfixed z) +{ + getDispatch()->glRotatex(angle, x, y, z); +} + +void glSampleCoverage(GLclampf value, GLboolean invert) +{ + getDispatch()->glSampleCoverage(value, invert); +} + +void glSampleCoveragex(GLclampx value, GLboolean invert) +{ + getDispatch()->glSampleCoveragex(value, invert); +} + +void glScalex(GLfixed x, GLfixed y, GLfixed z) +{ + getDispatch()->glScalex(x, y, z); +} + +void glScissor(GLint x, GLint y, GLsizei width, GLsizei height) +{ + getDispatch()->glScissor(x, y, width, height); +} + +void glShadeModel(GLenum mode) +{ + getDispatch()->glShadeModel(mode); +} + +void glStencilFunc(GLenum func, GLint ref, GLuint mask) +{ + getDispatch()->glStencilFunc(func, ref, mask); +} + +void glStencilMask(GLuint mask) +{ + getDispatch()->glStencilMask(mask); +} + +void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) +{ + getDispatch()->glStencilOp(fail, zfail, zpass); +} + +void glTexCoordPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) +{ + getDispatch()->glTexCoordPointer(size, type, stride, pointer); +} + +void glTexEnvi(GLenum target, GLenum pname, GLint param) +{ + getDispatch()->glTexEnvi(target, pname, param); +} + +void glTexEnvx(GLenum target, GLenum pname, GLfixed param) +{ + getDispatch()->glTexEnvx(target, pname, param); +} + +void glTexEnviv(GLenum target, GLenum pname, const GLint *params) +{ + getDispatch()->glTexEnviv(target, pname, params); +} + +void glTexEnvxv(GLenum target, GLenum pname, const GLfixed *params) +{ + getDispatch()->glTexEnvxv(target, pname, params); +} + +void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid *pixels) +{ + getDispatch()->glTexImage2D(target, level, internalformat, width, height, border, format, type, pixels); +} + +void glTexParameteri(GLenum target, GLenum pname, GLint param) +{ + getDispatch()->glTexParameteri(target, pname, param); +} + +void glTexParameterx(GLenum target, GLenum pname, GLfixed param) +{ + getDispatch()->glTexParameterx(target, pname, param); +} + +void glTexParameteriv(GLenum target, GLenum pname, const GLint *params) +{ + getDispatch()->glTexParameteriv(target, pname, params); +} + +void glTexParameterxv(GLenum target, GLenum pname, const GLfixed *params) +{ + getDispatch()->glTexParameterxv(target, pname, params); +} + +void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid *pixels) +{ + getDispatch()->glTexSubImage2D(target, level, xoffset, yoffset, width, height, format, type, pixels); +} + +void glTranslatex(GLfixed x, GLfixed y, GLfixed z) +{ + getDispatch()->glTranslatex(x, y, z); +} + +void glVertexPointer(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) +{ + getDispatch()->glVertexPointer(size, type, stride, pointer); +} + +void glViewport(GLint x, GLint y, GLsizei width, GLsizei height) +{ + getDispatch()->glViewport(x, y, width, height); +} + +void glPointSizePointerOES(GLenum type, GLsizei stride, const GLvoid *pointer) +{ + getDispatch()->glPointSizePointerOES(type, stride, pointer); +} + +void glBlendEquationSeparateOES(GLenum modeRGB, GLenum modeAlpha) +{ + getDispatch()->glBlendEquationSeparateOES(modeRGB, modeAlpha); +} + +void glBlendFuncSeparateOES(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) +{ + getDispatch()->glBlendFuncSeparateOES(srcRGB, dstRGB, srcAlpha, dstAlpha); +} + +void glBlendEquationOES(GLenum mode) +{ + getDispatch()->glBlendEquationOES(mode); +} + +void glDrawTexsOES(GLshort x, GLshort y, GLshort z, GLshort width, GLshort height) +{ + getDispatch()->glDrawTexsOES(x, y, z, width, height); +} + +void glDrawTexiOES(GLint x, GLint y, GLint z, GLint width, GLint height) +{ + getDispatch()->glDrawTexiOES(x, y, z, width, height); +} + +void glDrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed width, GLfixed height) +{ + getDispatch()->glDrawTexxOES(x, y, z, width, height); +} + +void glDrawTexsvOES(const GLshort *coords) +{ + getDispatch()->glDrawTexsvOES(coords); +} + +void glDrawTexivOES(const GLint *coords) +{ + getDispatch()->glDrawTexivOES(coords); +} + +void glDrawTexxvOES(const GLfixed *coords) +{ + getDispatch()->glDrawTexxvOES(coords); +} + +void glDrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat width, GLfloat height) +{ + getDispatch()->glDrawTexfOES(x, y, z, width, height); +} + +void glDrawTexfvOES(const GLfloat *coords) +{ + getDispatch()->glDrawTexfvOES(coords); +} + +void glEGLImageTargetTexture2DOES(GLenum target, GLeglImageOES image) +{ + getDispatch()->glEGLImageTargetTexture2DOES(target, image); +} + +void glEGLImageTargetRenderbufferStorageOES(GLenum target, GLeglImageOES image) +{ + getDispatch()->glEGLImageTargetRenderbufferStorageOES(target, image); +} + +void glAlphaFuncxOES(GLenum func, GLclampx ref) +{ + getDispatch()->glAlphaFuncxOES(func, ref); +} + +void glClearColorxOES(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha) +{ + getDispatch()->glClearColorxOES(red, green, blue, alpha); +} + +void glClearDepthxOES(GLclampx depth) +{ + getDispatch()->glClearDepthxOES(depth); +} + +void glClipPlanexOES(GLenum plane, const GLfixed *equation) +{ + getDispatch()->glClipPlanexOES(plane, equation); +} + +void glColor4xOES(GLfixed red, GLfixed green, GLfixed blue, GLfixed alpha) +{ + getDispatch()->glColor4xOES(red, green, blue, alpha); +} + +void glDepthRangexOES(GLclampx zNear, GLclampx zFar) +{ + getDispatch()->glDepthRangexOES(zNear, zFar); +} + +void glFogxOES(GLenum pname, GLfixed param) +{ + getDispatch()->glFogxOES(pname, param); +} + +void glFogxvOES(GLenum pname, const GLfixed *params) +{ + getDispatch()->glFogxvOES(pname, params); +} + +void glFrustumxOES(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) +{ + getDispatch()->glFrustumxOES(left, right, bottom, top, zNear, zFar); +} + +void glGetClipPlanexOES(GLenum pname, GLfixed eqn[4]) +{ + getDispatch()->glGetClipPlanexOES(pname, eqn); +} + +void glGetFixedvOES(GLenum pname, GLfixed *params) +{ + getDispatch()->glGetFixedvOES(pname, params); +} + +void glGetLightxvOES(GLenum light, GLenum pname, GLfixed *params) +{ + getDispatch()->glGetLightxvOES(light, pname, params); +} + +void glGetMaterialxvOES(GLenum face, GLenum pname, GLfixed *params) +{ + getDispatch()->glGetMaterialxvOES(face, pname, params); +} + +void glGetTexEnvxvOES(GLenum env, GLenum pname, GLfixed *params) +{ + getDispatch()->glGetTexEnvxvOES(env, pname, params); +} + +void glGetTexParameterxvOES(GLenum target, GLenum pname, GLfixed *params) +{ + getDispatch()->glGetTexParameterxvOES(target, pname, params); +} + +void glLightModelxOES(GLenum pname, GLfixed param) +{ + getDispatch()->glLightModelxOES(pname, param); +} + +void glLightModelxvOES(GLenum pname, const GLfixed *params) +{ + getDispatch()->glLightModelxvOES(pname, params); +} + +void glLightxOES(GLenum light, GLenum pname, GLfixed param) +{ + getDispatch()->glLightxOES(light, pname, param); +} + +void glLightxvOES(GLenum light, GLenum pname, const GLfixed *params) +{ + getDispatch()->glLightxvOES(light, pname, params); +} + +void glLineWidthxOES(GLfixed width) +{ + getDispatch()->glLineWidthxOES(width); +} + +void glLoadMatrixxOES(const GLfixed *m) +{ + getDispatch()->glLoadMatrixxOES(m); +} + +void glMaterialxOES(GLenum face, GLenum pname, GLfixed param) +{ + getDispatch()->glMaterialxOES(face, pname, param); +} + +void glMaterialxvOES(GLenum face, GLenum pname, const GLfixed *params) +{ + getDispatch()->glMaterialxvOES(face, pname, params); +} + +void glMultMatrixxOES(const GLfixed *m) +{ + getDispatch()->glMultMatrixxOES(m); +} + +void glMultiTexCoord4xOES(GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q) +{ + getDispatch()->glMultiTexCoord4xOES(target, s, t, r, q); +} + +void glNormal3xOES(GLfixed nx, GLfixed ny, GLfixed nz) +{ + getDispatch()->glNormal3xOES(nx, ny, nz); +} + +void glOrthoxOES(GLfixed left, GLfixed right, GLfixed bottom, GLfixed top, GLfixed zNear, GLfixed zFar) +{ + getDispatch()->glOrthoxOES(left, right, bottom, top, zNear, zFar); +} + +void glPointParameterxOES(GLenum pname, GLfixed param) +{ + getDispatch()->glPointParameterxOES(pname, param); +} + +void glPointParameterxvOES(GLenum pname, const GLfixed *params) +{ + getDispatch()->glPointParameterxvOES(pname, params); +} + +void glPointSizexOES(GLfixed size) +{ + getDispatch()->glPointSizexOES(size); +} + +void glPolygonOffsetxOES(GLfixed factor, GLfixed units) +{ + getDispatch()->glPolygonOffsetxOES(factor, units); +} + +void glRotatexOES(GLfixed angle, GLfixed x, GLfixed y, GLfixed z) +{ + getDispatch()->glRotatexOES(angle, x, y, z); +} + +void glSampleCoveragexOES(GLclampx value, GLboolean invert) +{ + getDispatch()->glSampleCoveragexOES(value, invert); +} + +void glScalexOES(GLfixed x, GLfixed y, GLfixed z) +{ + getDispatch()->glScalexOES(x, y, z); +} + +void glTexEnvxOES(GLenum target, GLenum pname, GLfixed param) +{ + getDispatch()->glTexEnvxOES(target, pname, param); +} + +void glTexEnvxvOES(GLenum target, GLenum pname, const GLfixed *params) +{ + getDispatch()->glTexEnvxvOES(target, pname, params); +} + +void glTexParameterxOES(GLenum target, GLenum pname, GLfixed param) +{ + getDispatch()->glTexParameterxOES(target, pname, param); +} + +void glTexParameterxvOES(GLenum target, GLenum pname, const GLfixed *params) +{ + getDispatch()->glTexParameterxvOES(target, pname, params); +} + +void glTranslatexOES(GLfixed x, GLfixed y, GLfixed z) +{ + getDispatch()->glTranslatexOES(x, y, z); +} + +GLboolean glIsRenderbufferOES(GLuint renderbuffer) +{ + return getDispatch()->glIsRenderbufferOES(renderbuffer); +} + +void glBindRenderbufferOES(GLenum target, GLuint renderbuffer) +{ + getDispatch()->glBindRenderbufferOES(target, renderbuffer); +} + +void glDeleteRenderbuffersOES(GLsizei n, const GLuint *renderbuffers) +{ + getDispatch()->glDeleteRenderbuffersOES(n, renderbuffers); +} + +void glGenRenderbuffersOES(GLsizei n, GLuint *renderbuffers) +{ + getDispatch()->glGenRenderbuffersOES(n, renderbuffers); +} + +void glRenderbufferStorageOES(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) +{ + getDispatch()->glRenderbufferStorageOES(target, internalformat, width, height); +} + +void glGetRenderbufferParameterivOES(GLenum target, GLenum pname, GLint *params) +{ + getDispatch()->glGetRenderbufferParameterivOES(target, pname, params); +} + +GLboolean glIsFramebufferOES(GLuint framebuffer) +{ + return getDispatch()->glIsFramebufferOES(framebuffer); +} + +void glBindFramebufferOES(GLenum target, GLuint framebuffer) +{ + getDispatch()->glBindFramebufferOES(target, framebuffer); +} + +void glDeleteFramebuffersOES(GLsizei n, const GLuint *framebuffers) +{ + getDispatch()->glDeleteFramebuffersOES(n, framebuffers); +} + +void glGenFramebuffersOES(GLsizei n, GLuint *framebuffers) +{ + getDispatch()->glGenFramebuffersOES(n, framebuffers); +} + +GLenum glCheckFramebufferStatusOES(GLenum target) +{ + return getDispatch()->glCheckFramebufferStatusOES(target); +} + +void glFramebufferRenderbufferOES(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) +{ + getDispatch()->glFramebufferRenderbufferOES(target, attachment, renderbuffertarget, renderbuffer); +} + +void glFramebufferTexture2DOES(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + getDispatch()->glFramebufferTexture2DOES(target, attachment, textarget, texture, level); +} + +void glGetFramebufferAttachmentParameterivOES(GLenum target, GLenum attachment, GLenum pname, GLint *params) +{ + getDispatch()->glGetFramebufferAttachmentParameterivOES(target, attachment, pname, params); +} + +void glGenerateMipmapOES(GLenum target) +{ + getDispatch()->glGenerateMipmapOES(target); +} + +void* glMapBufferOES(GLenum target, GLenum access) +{ + return getDispatch()->glMapBufferOES(target, access); +} + +GLboolean glUnmapBufferOES(GLenum target) +{ + return getDispatch()->glUnmapBufferOES(target); +} + +void glGetBufferPointervOES(GLenum target, GLenum pname, GLvoid **ptr) +{ + getDispatch()->glGetBufferPointervOES(target, pname, ptr); +} + +void glCurrentPaletteMatrixOES(GLuint matrixpaletteindex) +{ + getDispatch()->glCurrentPaletteMatrixOES(matrixpaletteindex); +} + +void glLoadPaletteFromModelViewMatrixOES() +{ + getDispatch()->glLoadPaletteFromModelViewMatrixOES(); +} + +void glMatrixIndexPointerOES(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) +{ + getDispatch()->glMatrixIndexPointerOES(size, type, stride, pointer); +} + +void glWeightPointerOES(GLint size, GLenum type, GLsizei stride, const GLvoid *pointer) +{ + getDispatch()->glWeightPointerOES(size, type, stride, pointer); +} + +GLbitfield glQueryMatrixxOES(GLfixed mantissa[16], GLint exponent[16]) +{ + return getDispatch()->glQueryMatrixxOES(mantissa, exponent); +} + +void glDepthRangefOES(GLclampf zNear, GLclampf zFar) +{ + getDispatch()->glDepthRangefOES(zNear, zFar); +} + +void glFrustumfOES(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) +{ + getDispatch()->glFrustumfOES(left, right, bottom, top, zNear, zFar); +} + +void glOrthofOES(GLfloat left, GLfloat right, GLfloat bottom, GLfloat top, GLfloat zNear, GLfloat zFar) +{ + getDispatch()->glOrthofOES(left, right, bottom, top, zNear, zFar); +} + +void glClipPlanefOES(GLenum plane, const GLfloat *equation) +{ + getDispatch()->glClipPlanefOES(plane, equation); +} + +void glGetClipPlanefOES(GLenum pname, GLfloat eqn[4]) +{ + getDispatch()->glGetClipPlanefOES(pname, eqn); +} + +void glClearDepthfOES(GLclampf depth) +{ + getDispatch()->glClearDepthfOES(depth); +} + +void glTexGenfOES(GLenum coord, GLenum pname, GLfloat param) +{ + getDispatch()->glTexGenfOES(coord, pname, param); +} + +void glTexGenfvOES(GLenum coord, GLenum pname, const GLfloat *params) +{ + getDispatch()->glTexGenfvOES(coord, pname, params); +} + +void glTexGeniOES(GLenum coord, GLenum pname, GLint param) +{ + getDispatch()->glTexGeniOES(coord, pname, param); +} + +void glTexGenivOES(GLenum coord, GLenum pname, const GLint *params) +{ + getDispatch()->glTexGenivOES(coord, pname, params); +} + +void glTexGenxOES(GLenum coord, GLenum pname, GLfixed param) +{ + getDispatch()->glTexGenxOES(coord, pname, param); +} + +void glTexGenxvOES(GLenum coord, GLenum pname, const GLfixed *params) +{ + getDispatch()->glTexGenxvOES(coord, pname, params); +} + +void glGetTexGenfvOES(GLenum coord, GLenum pname, GLfloat *params) +{ + getDispatch()->glGetTexGenfvOES(coord, pname, params); +} + +void glGetTexGenivOES(GLenum coord, GLenum pname, GLint *params) +{ + getDispatch()->glGetTexGenivOES(coord, pname, params); +} + +void glGetTexGenxvOES(GLenum coord, GLenum pname, GLfixed *params) +{ + getDispatch()->glGetTexGenxvOES(coord, pname, params); +} + +void glBindVertexArrayOES(GLuint array) +{ + getDispatch()->glBindVertexArrayOES(array); +} + +void glDeleteVertexArraysOES(GLsizei n, const GLuint *arrays) +{ + getDispatch()->glDeleteVertexArraysOES(n, arrays); +} + +void glGenVertexArraysOES(GLsizei n, GLuint *arrays) +{ + getDispatch()->glGenVertexArraysOES(n, arrays); +} + +GLboolean glIsVertexArrayOES(GLuint array) +{ + return getDispatch()->glIsVertexArrayOES(array); +} + +void glDiscardFramebufferEXT(GLenum target, GLsizei numAttachments, const GLenum *attachments) +{ + getDispatch()->glDiscardFramebufferEXT(target, numAttachments, attachments); +} + +void glMultiDrawArraysEXT(GLenum mode, GLint *first, GLsizei *count, GLsizei primcount) +{ + getDispatch()->glMultiDrawArraysEXT(mode, first, count, primcount); +} + +void glMultiDrawElementsEXT(GLenum mode, const GLsizei *count, GLenum type, const GLvoid **indices, GLsizei primcount) +{ + getDispatch()->glMultiDrawElementsEXT(mode, count, type, indices, primcount); +} + +void glClipPlanefIMG(GLenum p, const GLfloat *eqn) +{ + getDispatch()->glClipPlanefIMG(p, eqn); +} + +void glClipPlanexIMG(GLenum p, const GLfixed *eqn) +{ + getDispatch()->glClipPlanexIMG(p, eqn); +} + +void glRenderbufferStorageMultisampleIMG(GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) +{ + getDispatch()->glRenderbufferStorageMultisampleIMG(target, samples, internalformat, width, height); +} + +void glFramebufferTexture2DMultisampleIMG(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level, GLsizei samples) +{ + getDispatch()->glFramebufferTexture2DMultisampleIMG(target, attachment, textarget, texture, level, samples); +} + +void glDeleteFencesNV(GLsizei n, const GLuint *fences) +{ + getDispatch()->glDeleteFencesNV(n, fences); +} + +void glGenFencesNV(GLsizei n, GLuint *fences) +{ + getDispatch()->glGenFencesNV(n, fences); +} + +GLboolean glIsFenceNV(GLuint fence) +{ + return getDispatch()->glIsFenceNV(fence); +} + +GLboolean glTestFenceNV(GLuint fence) +{ + return getDispatch()->glTestFenceNV(fence); +} + +void glGetFenceivNV(GLuint fence, GLenum pname, GLint *params) +{ + getDispatch()->glGetFenceivNV(fence, pname, params); +} + +void glFinishFenceNV(GLuint fence) +{ + getDispatch()->glFinishFenceNV(fence); +} + +void glSetFenceNV(GLuint fence, GLenum condition) +{ + getDispatch()->glSetFenceNV(fence, condition); +} + +void glGetDriverControlsQCOM(GLint *num, GLsizei size, GLuint *driverControls) +{ + getDispatch()->glGetDriverControlsQCOM(num, size, driverControls); +} + +void glGetDriverControlStringQCOM(GLuint driverControl, GLsizei bufSize, GLsizei *length, GLchar *driverControlString) +{ + getDispatch()->glGetDriverControlStringQCOM(driverControl, bufSize, length, driverControlString); +} + +void glEnableDriverControlQCOM(GLuint driverControl) +{ + getDispatch()->glEnableDriverControlQCOM(driverControl); +} + +void glDisableDriverControlQCOM(GLuint driverControl) +{ + getDispatch()->glDisableDriverControlQCOM(driverControl); +} + +void glExtGetTexturesQCOM(GLuint *textures, GLint maxTextures, GLint *numTextures) +{ + getDispatch()->glExtGetTexturesQCOM(textures, maxTextures, numTextures); +} + +void glExtGetBuffersQCOM(GLuint *buffers, GLint maxBuffers, GLint *numBuffers) +{ + getDispatch()->glExtGetBuffersQCOM(buffers, maxBuffers, numBuffers); +} + +void glExtGetRenderbuffersQCOM(GLuint *renderbuffers, GLint maxRenderbuffers, GLint *numRenderbuffers) +{ + getDispatch()->glExtGetRenderbuffersQCOM(renderbuffers, maxRenderbuffers, numRenderbuffers); +} + +void glExtGetFramebuffersQCOM(GLuint *framebuffers, GLint maxFramebuffers, GLint *numFramebuffers) +{ + getDispatch()->glExtGetFramebuffersQCOM(framebuffers, maxFramebuffers, numFramebuffers); +} + +void glExtGetTexLevelParameterivQCOM(GLuint texture, GLenum face, GLint level, GLenum pname, GLint *params) +{ + getDispatch()->glExtGetTexLevelParameterivQCOM(texture, face, level, pname, params); +} + +void glExtTexObjectStateOverrideiQCOM(GLenum target, GLenum pname, GLint param) +{ + getDispatch()->glExtTexObjectStateOverrideiQCOM(target, pname, param); +} + +void glExtGetTexSubImageQCOM(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint zoffset, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, GLvoid *texels) +{ + getDispatch()->glExtGetTexSubImageQCOM(target, level, xoffset, yoffset, zoffset, width, height, depth, format, type, texels); +} + +void glExtGetBufferPointervQCOM(GLenum target, GLvoid **params) +{ + getDispatch()->glExtGetBufferPointervQCOM(target, params); +} + +void glExtGetShadersQCOM(GLuint *shaders, GLint maxShaders, GLint *numShaders) +{ + getDispatch()->glExtGetShadersQCOM(shaders, maxShaders, numShaders); +} + +void glExtGetProgramsQCOM(GLuint *programs, GLint maxPrograms, GLint *numPrograms) +{ + getDispatch()->glExtGetProgramsQCOM(programs, maxPrograms, numPrograms); +} + +GLboolean glExtIsProgramBinaryQCOM(GLuint program) +{ + return getDispatch()->glExtIsProgramBinaryQCOM(program); +} + +void glExtGetProgramBinarySourceQCOM(GLuint program, GLenum shadertype, GLchar *source, GLint *length) +{ + getDispatch()->glExtGetProgramBinarySourceQCOM(program, shadertype, source, length); +} + +void glStartTilingQCOM(GLuint x, GLuint y, GLuint width, GLuint height, GLbitfield preserveMask) +{ + getDispatch()->glStartTilingQCOM(x, y, width, height, preserveMask); +} + +void glEndTilingQCOM(GLbitfield preserveMask) +{ + getDispatch()->glEndTilingQCOM(preserveMask); +} + diff --git a/emulator/opengl/tests/gles_android_wrapper/gles_dispatch.cpp b/emulator/opengl/tests/gles_android_wrapper/gles_dispatch.cpp new file mode 100644 index 0000000..0a17624 --- /dev/null +++ b/emulator/opengl/tests/gles_android_wrapper/gles_dispatch.cpp @@ -0,0 +1,298 @@ +/* +* Copyright (C) 2011 The Android Open Source Project +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ +#include "gles_dispatch.h" +#include <stdio.h> +#include <dlfcn.h> + +gles_dispatch *create_gles_dispatch(void *gles_android) +{ + gles_dispatch *disp = new gles_dispatch; + + void *ptr; + ptr = dlsym(gles_android,"glAlphaFunc"); disp->set_glAlphaFunc((glAlphaFunc_t)ptr); + ptr = dlsym(gles_android,"glClearColor"); disp->set_glClearColor((glClearColor_t)ptr); + ptr = dlsym(gles_android,"glClearDepthf"); disp->set_glClearDepthf((glClearDepthf_t)ptr); + ptr = dlsym(gles_android,"glClipPlanef"); disp->set_glClipPlanef((glClipPlanef_t)ptr); + ptr = dlsym(gles_android,"glColor4f"); disp->set_glColor4f((glColor4f_t)ptr); + ptr = dlsym(gles_android,"glDepthRangef"); disp->set_glDepthRangef((glDepthRangef_t)ptr); + ptr = dlsym(gles_android,"glFogf"); disp->set_glFogf((glFogf_t)ptr); + ptr = dlsym(gles_android,"glFogfv"); disp->set_glFogfv((glFogfv_t)ptr); + ptr = dlsym(gles_android,"glFrustumf"); disp->set_glFrustumf((glFrustumf_t)ptr); + ptr = dlsym(gles_android,"glGetClipPlanef"); disp->set_glGetClipPlanef((glGetClipPlanef_t)ptr); + ptr = dlsym(gles_android,"glGetFloatv"); disp->set_glGetFloatv((glGetFloatv_t)ptr); + ptr = dlsym(gles_android,"glGetLightfv"); disp->set_glGetLightfv((glGetLightfv_t)ptr); + ptr = dlsym(gles_android,"glGetMaterialfv"); disp->set_glGetMaterialfv((glGetMaterialfv_t)ptr); + ptr = dlsym(gles_android,"glGetTexEnvfv"); disp->set_glGetTexEnvfv((glGetTexEnvfv_t)ptr); + ptr = dlsym(gles_android,"glGetTexParameterfv"); disp->set_glGetTexParameterfv((glGetTexParameterfv_t)ptr); + ptr = dlsym(gles_android,"glLightModelf"); disp->set_glLightModelf((glLightModelf_t)ptr); + ptr = dlsym(gles_android,"glLightModelfv"); disp->set_glLightModelfv((glLightModelfv_t)ptr); + ptr = dlsym(gles_android,"glLightf"); disp->set_glLightf((glLightf_t)ptr); + ptr = dlsym(gles_android,"glLightfv"); disp->set_glLightfv((glLightfv_t)ptr); + ptr = dlsym(gles_android,"glLineWidth"); disp->set_glLineWidth((glLineWidth_t)ptr); + ptr = dlsym(gles_android,"glLoadMatrixf"); disp->set_glLoadMatrixf((glLoadMatrixf_t)ptr); + ptr = dlsym(gles_android,"glMaterialf"); disp->set_glMaterialf((glMaterialf_t)ptr); + ptr = dlsym(gles_android,"glMaterialfv"); disp->set_glMaterialfv((glMaterialfv_t)ptr); + ptr = dlsym(gles_android,"glMultMatrixf"); disp->set_glMultMatrixf((glMultMatrixf_t)ptr); + ptr = dlsym(gles_android,"glMultiTexCoord4f"); disp->set_glMultiTexCoord4f((glMultiTexCoord4f_t)ptr); + ptr = dlsym(gles_android,"glNormal3f"); disp->set_glNormal3f((glNormal3f_t)ptr); + ptr = dlsym(gles_android,"glOrthof"); disp->set_glOrthof((glOrthof_t)ptr); + ptr = dlsym(gles_android,"glPointParameterf"); disp->set_glPointParameterf((glPointParameterf_t)ptr); + ptr = dlsym(gles_android,"glPointParameterfv"); disp->set_glPointParameterfv((glPointParameterfv_t)ptr); + ptr = dlsym(gles_android,"glPointSize"); disp->set_glPointSize((glPointSize_t)ptr); + ptr = dlsym(gles_android,"glPolygonOffset"); disp->set_glPolygonOffset((glPolygonOffset_t)ptr); + ptr = dlsym(gles_android,"glRotatef"); disp->set_glRotatef((glRotatef_t)ptr); + ptr = dlsym(gles_android,"glScalef"); disp->set_glScalef((glScalef_t)ptr); + ptr = dlsym(gles_android,"glTexEnvf"); disp->set_glTexEnvf((glTexEnvf_t)ptr); + ptr = dlsym(gles_android,"glTexEnvfv"); disp->set_glTexEnvfv((glTexEnvfv_t)ptr); + ptr = dlsym(gles_android,"glTexParameterf"); disp->set_glTexParameterf((glTexParameterf_t)ptr); + ptr = dlsym(gles_android,"glTexParameterfv"); disp->set_glTexParameterfv((glTexParameterfv_t)ptr); + ptr = dlsym(gles_android,"glTranslatef"); disp->set_glTranslatef((glTranslatef_t)ptr); + ptr = dlsym(gles_android,"glActiveTexture"); disp->set_glActiveTexture((glActiveTexture_t)ptr); + ptr = dlsym(gles_android,"glAlphaFuncx"); disp->set_glAlphaFuncx((glAlphaFuncx_t)ptr); + ptr = dlsym(gles_android,"glBindBuffer"); disp->set_glBindBuffer((glBindBuffer_t)ptr); + ptr = dlsym(gles_android,"glBindTexture"); disp->set_glBindTexture((glBindTexture_t)ptr); + ptr = dlsym(gles_android,"glBlendFunc"); disp->set_glBlendFunc((glBlendFunc_t)ptr); + ptr = dlsym(gles_android,"glBufferData"); disp->set_glBufferData((glBufferData_t)ptr); + ptr = dlsym(gles_android,"glBufferSubData"); disp->set_glBufferSubData((glBufferSubData_t)ptr); + ptr = dlsym(gles_android,"glClear"); disp->set_glClear((glClear_t)ptr); + ptr = dlsym(gles_android,"glClearColorx"); disp->set_glClearColorx((glClearColorx_t)ptr); + ptr = dlsym(gles_android,"glClearDepthx"); disp->set_glClearDepthx((glClearDepthx_t)ptr); + ptr = dlsym(gles_android,"glClearStencil"); disp->set_glClearStencil((glClearStencil_t)ptr); + ptr = dlsym(gles_android,"glClientActiveTexture"); disp->set_glClientActiveTexture((glClientActiveTexture_t)ptr); + ptr = dlsym(gles_android,"glClipPlanex"); disp->set_glClipPlanex((glClipPlanex_t)ptr); + ptr = dlsym(gles_android,"glColor4ub"); disp->set_glColor4ub((glColor4ub_t)ptr); + ptr = dlsym(gles_android,"glColor4x"); disp->set_glColor4x((glColor4x_t)ptr); + ptr = dlsym(gles_android,"glColorMask"); disp->set_glColorMask((glColorMask_t)ptr); + ptr = dlsym(gles_android,"glColorPointer"); disp->set_glColorPointer((glColorPointer_t)ptr); + ptr = dlsym(gles_android,"glCompressedTexImage2D"); disp->set_glCompressedTexImage2D((glCompressedTexImage2D_t)ptr); + ptr = dlsym(gles_android,"glCompressedTexSubImage2D"); disp->set_glCompressedTexSubImage2D((glCompressedTexSubImage2D_t)ptr); + ptr = dlsym(gles_android,"glCopyTexImage2D"); disp->set_glCopyTexImage2D((glCopyTexImage2D_t)ptr); + ptr = dlsym(gles_android,"glCopyTexSubImage2D"); disp->set_glCopyTexSubImage2D((glCopyTexSubImage2D_t)ptr); + ptr = dlsym(gles_android,"glCullFace"); disp->set_glCullFace((glCullFace_t)ptr); + ptr = dlsym(gles_android,"glDeleteBuffers"); disp->set_glDeleteBuffers((glDeleteBuffers_t)ptr); + ptr = dlsym(gles_android,"glDeleteTextures"); disp->set_glDeleteTextures((glDeleteTextures_t)ptr); + ptr = dlsym(gles_android,"glDepthFunc"); disp->set_glDepthFunc((glDepthFunc_t)ptr); + ptr = dlsym(gles_android,"glDepthMask"); disp->set_glDepthMask((glDepthMask_t)ptr); + ptr = dlsym(gles_android,"glDepthRangex"); disp->set_glDepthRangex((glDepthRangex_t)ptr); + ptr = dlsym(gles_android,"glDisable"); disp->set_glDisable((glDisable_t)ptr); + ptr = dlsym(gles_android,"glDisableClientState"); disp->set_glDisableClientState((glDisableClientState_t)ptr); + ptr = dlsym(gles_android,"glDrawArrays"); disp->set_glDrawArrays((glDrawArrays_t)ptr); + ptr = dlsym(gles_android,"glDrawElements"); disp->set_glDrawElements((glDrawElements_t)ptr); + ptr = dlsym(gles_android,"glEnable"); disp->set_glEnable((glEnable_t)ptr); + ptr = dlsym(gles_android,"glEnableClientState"); disp->set_glEnableClientState((glEnableClientState_t)ptr); + ptr = dlsym(gles_android,"glFinish"); disp->set_glFinish((glFinish_t)ptr); + ptr = dlsym(gles_android,"glFlush"); disp->set_glFlush((glFlush_t)ptr); + ptr = dlsym(gles_android,"glFogx"); disp->set_glFogx((glFogx_t)ptr); + ptr = dlsym(gles_android,"glFogxv"); disp->set_glFogxv((glFogxv_t)ptr); + ptr = dlsym(gles_android,"glFrontFace"); disp->set_glFrontFace((glFrontFace_t)ptr); + ptr = dlsym(gles_android,"glFrustumx"); disp->set_glFrustumx((glFrustumx_t)ptr); + ptr = dlsym(gles_android,"glGetBooleanv"); disp->set_glGetBooleanv((glGetBooleanv_t)ptr); + ptr = dlsym(gles_android,"glGetBufferParameteriv"); disp->set_glGetBufferParameteriv((glGetBufferParameteriv_t)ptr); + ptr = dlsym(gles_android,"glGetClipPlanex"); disp->set_glGetClipPlanex((glGetClipPlanex_t)ptr); + ptr = dlsym(gles_android,"glGenBuffers"); disp->set_glGenBuffers((glGenBuffers_t)ptr); + ptr = dlsym(gles_android,"glGenTextures"); disp->set_glGenTextures((glGenTextures_t)ptr); + ptr = dlsym(gles_android,"glGetError"); disp->set_glGetError((glGetError_t)ptr); + ptr = dlsym(gles_android,"glGetFixedv"); disp->set_glGetFixedv((glGetFixedv_t)ptr); + ptr = dlsym(gles_android,"glGetIntegerv"); disp->set_glGetIntegerv((glGetIntegerv_t)ptr); + ptr = dlsym(gles_android,"glGetLightxv"); disp->set_glGetLightxv((glGetLightxv_t)ptr); + ptr = dlsym(gles_android,"glGetMaterialxv"); disp->set_glGetMaterialxv((glGetMaterialxv_t)ptr); + ptr = dlsym(gles_android,"glGetPointerv"); disp->set_glGetPointerv((glGetPointerv_t)ptr); + ptr = dlsym(gles_android,"glGetString"); disp->set_glGetString((glGetString_t)ptr); + ptr = dlsym(gles_android,"glGetTexEnviv"); disp->set_glGetTexEnviv((glGetTexEnviv_t)ptr); + ptr = dlsym(gles_android,"glGetTexEnvxv"); disp->set_glGetTexEnvxv((glGetTexEnvxv_t)ptr); + ptr = dlsym(gles_android,"glGetTexParameteriv"); disp->set_glGetTexParameteriv((glGetTexParameteriv_t)ptr); + ptr = dlsym(gles_android,"glGetTexParameterxv"); disp->set_glGetTexParameterxv((glGetTexParameterxv_t)ptr); + ptr = dlsym(gles_android,"glHint"); disp->set_glHint((glHint_t)ptr); + ptr = dlsym(gles_android,"glIsBuffer"); disp->set_glIsBuffer((glIsBuffer_t)ptr); + ptr = dlsym(gles_android,"glIsEnabled"); disp->set_glIsEnabled((glIsEnabled_t)ptr); + ptr = dlsym(gles_android,"glIsTexture"); disp->set_glIsTexture((glIsTexture_t)ptr); + ptr = dlsym(gles_android,"glLightModelx"); disp->set_glLightModelx((glLightModelx_t)ptr); + ptr = dlsym(gles_android,"glLightModelxv"); disp->set_glLightModelxv((glLightModelxv_t)ptr); + ptr = dlsym(gles_android,"glLightx"); disp->set_glLightx((glLightx_t)ptr); + ptr = dlsym(gles_android,"glLightxv"); disp->set_glLightxv((glLightxv_t)ptr); + ptr = dlsym(gles_android,"glLineWidthx"); disp->set_glLineWidthx((glLineWidthx_t)ptr); + ptr = dlsym(gles_android,"glLoadIdentity"); disp->set_glLoadIdentity((glLoadIdentity_t)ptr); + ptr = dlsym(gles_android,"glLoadMatrixx"); disp->set_glLoadMatrixx((glLoadMatrixx_t)ptr); + ptr = dlsym(gles_android,"glLogicOp"); disp->set_glLogicOp((glLogicOp_t)ptr); + ptr = dlsym(gles_android,"glMaterialx"); disp->set_glMaterialx((glMaterialx_t)ptr); + ptr = dlsym(gles_android,"glMaterialxv"); disp->set_glMaterialxv((glMaterialxv_t)ptr); + ptr = dlsym(gles_android,"glMatrixMode"); disp->set_glMatrixMode((glMatrixMode_t)ptr); + ptr = dlsym(gles_android,"glMultMatrixx"); disp->set_glMultMatrixx((glMultMatrixx_t)ptr); + ptr = dlsym(gles_android,"glMultiTexCoord4x"); disp->set_glMultiTexCoord4x((glMultiTexCoord4x_t)ptr); + ptr = dlsym(gles_android,"glNormal3x"); disp->set_glNormal3x((glNormal3x_t)ptr); + ptr = dlsym(gles_android,"glNormalPointer"); disp->set_glNormalPointer((glNormalPointer_t)ptr); + ptr = dlsym(gles_android,"glOrthox"); disp->set_glOrthox((glOrthox_t)ptr); + ptr = dlsym(gles_android,"glPixelStorei"); disp->set_glPixelStorei((glPixelStorei_t)ptr); + ptr = dlsym(gles_android,"glPointParameterx"); disp->set_glPointParameterx((glPointParameterx_t)ptr); + ptr = dlsym(gles_android,"glPointParameterxv"); disp->set_glPointParameterxv((glPointParameterxv_t)ptr); + ptr = dlsym(gles_android,"glPointSizex"); disp->set_glPointSizex((glPointSizex_t)ptr); + ptr = dlsym(gles_android,"glPolygonOffsetx"); disp->set_glPolygonOffsetx((glPolygonOffsetx_t)ptr); + ptr = dlsym(gles_android,"glPopMatrix"); disp->set_glPopMatrix((glPopMatrix_t)ptr); + ptr = dlsym(gles_android,"glPushMatrix"); disp->set_glPushMatrix((glPushMatrix_t)ptr); + ptr = dlsym(gles_android,"glReadPixels"); disp->set_glReadPixels((glReadPixels_t)ptr); + ptr = dlsym(gles_android,"glRotatex"); disp->set_glRotatex((glRotatex_t)ptr); + ptr = dlsym(gles_android,"glSampleCoverage"); disp->set_glSampleCoverage((glSampleCoverage_t)ptr); + ptr = dlsym(gles_android,"glSampleCoveragex"); disp->set_glSampleCoveragex((glSampleCoveragex_t)ptr); + ptr = dlsym(gles_android,"glScalex"); disp->set_glScalex((glScalex_t)ptr); + ptr = dlsym(gles_android,"glScissor"); disp->set_glScissor((glScissor_t)ptr); + ptr = dlsym(gles_android,"glShadeModel"); disp->set_glShadeModel((glShadeModel_t)ptr); + ptr = dlsym(gles_android,"glStencilFunc"); disp->set_glStencilFunc((glStencilFunc_t)ptr); + ptr = dlsym(gles_android,"glStencilMask"); disp->set_glStencilMask((glStencilMask_t)ptr); + ptr = dlsym(gles_android,"glStencilOp"); disp->set_glStencilOp((glStencilOp_t)ptr); + ptr = dlsym(gles_android,"glTexCoordPointer"); disp->set_glTexCoordPointer((glTexCoordPointer_t)ptr); + ptr = dlsym(gles_android,"glTexEnvi"); disp->set_glTexEnvi((glTexEnvi_t)ptr); + ptr = dlsym(gles_android,"glTexEnvx"); disp->set_glTexEnvx((glTexEnvx_t)ptr); + ptr = dlsym(gles_android,"glTexEnviv"); disp->set_glTexEnviv((glTexEnviv_t)ptr); + ptr = dlsym(gles_android,"glTexEnvxv"); disp->set_glTexEnvxv((glTexEnvxv_t)ptr); + ptr = dlsym(gles_android,"glTexImage2D"); disp->set_glTexImage2D((glTexImage2D_t)ptr); + ptr = dlsym(gles_android,"glTexParameteri"); disp->set_glTexParameteri((glTexParameteri_t)ptr); + ptr = dlsym(gles_android,"glTexParameterx"); disp->set_glTexParameterx((glTexParameterx_t)ptr); + ptr = dlsym(gles_android,"glTexParameteriv"); disp->set_glTexParameteriv((glTexParameteriv_t)ptr); + ptr = dlsym(gles_android,"glTexParameterxv"); disp->set_glTexParameterxv((glTexParameterxv_t)ptr); + ptr = dlsym(gles_android,"glTexSubImage2D"); disp->set_glTexSubImage2D((glTexSubImage2D_t)ptr); + ptr = dlsym(gles_android,"glTranslatex"); disp->set_glTranslatex((glTranslatex_t)ptr); + ptr = dlsym(gles_android,"glVertexPointer"); disp->set_glVertexPointer((glVertexPointer_t)ptr); + ptr = dlsym(gles_android,"glViewport"); disp->set_glViewport((glViewport_t)ptr); + ptr = dlsym(gles_android,"glPointSizePointerOES"); disp->set_glPointSizePointerOES((glPointSizePointerOES_t)ptr); + ptr = dlsym(gles_android,"glBlendEquationSeparateOES"); disp->set_glBlendEquationSeparateOES((glBlendEquationSeparateOES_t)ptr); + ptr = dlsym(gles_android,"glBlendFuncSeparateOES"); disp->set_glBlendFuncSeparateOES((glBlendFuncSeparateOES_t)ptr); + ptr = dlsym(gles_android,"glBlendEquationOES"); disp->set_glBlendEquationOES((glBlendEquationOES_t)ptr); + ptr = dlsym(gles_android,"glDrawTexsOES"); disp->set_glDrawTexsOES((glDrawTexsOES_t)ptr); + ptr = dlsym(gles_android,"glDrawTexiOES"); disp->set_glDrawTexiOES((glDrawTexiOES_t)ptr); + ptr = dlsym(gles_android,"glDrawTexxOES"); disp->set_glDrawTexxOES((glDrawTexxOES_t)ptr); + ptr = dlsym(gles_android,"glDrawTexsvOES"); disp->set_glDrawTexsvOES((glDrawTexsvOES_t)ptr); + ptr = dlsym(gles_android,"glDrawTexivOES"); disp->set_glDrawTexivOES((glDrawTexivOES_t)ptr); + ptr = dlsym(gles_android,"glDrawTexxvOES"); disp->set_glDrawTexxvOES((glDrawTexxvOES_t)ptr); + ptr = dlsym(gles_android,"glDrawTexfOES"); disp->set_glDrawTexfOES((glDrawTexfOES_t)ptr); + ptr = dlsym(gles_android,"glDrawTexfvOES"); disp->set_glDrawTexfvOES((glDrawTexfvOES_t)ptr); + ptr = dlsym(gles_android,"glEGLImageTargetTexture2DOES"); disp->set_glEGLImageTargetTexture2DOES((glEGLImageTargetTexture2DOES_t)ptr); + ptr = dlsym(gles_android,"glEGLImageTargetRenderbufferStorageOES"); disp->set_glEGLImageTargetRenderbufferStorageOES((glEGLImageTargetRenderbufferStorageOES_t)ptr); + ptr = dlsym(gles_android,"glAlphaFuncxOES"); disp->set_glAlphaFuncxOES((glAlphaFuncxOES_t)ptr); + ptr = dlsym(gles_android,"glClearColorxOES"); disp->set_glClearColorxOES((glClearColorxOES_t)ptr); + ptr = dlsym(gles_android,"glClearDepthxOES"); disp->set_glClearDepthxOES((glClearDepthxOES_t)ptr); + ptr = dlsym(gles_android,"glClipPlanexOES"); disp->set_glClipPlanexOES((glClipPlanexOES_t)ptr); + ptr = dlsym(gles_android,"glColor4xOES"); disp->set_glColor4xOES((glColor4xOES_t)ptr); + ptr = dlsym(gles_android,"glDepthRangexOES"); disp->set_glDepthRangexOES((glDepthRangexOES_t)ptr); + ptr = dlsym(gles_android,"glFogxOES"); disp->set_glFogxOES((glFogxOES_t)ptr); + ptr = dlsym(gles_android,"glFogxvOES"); disp->set_glFogxvOES((glFogxvOES_t)ptr); + ptr = dlsym(gles_android,"glFrustumxOES"); disp->set_glFrustumxOES((glFrustumxOES_t)ptr); + ptr = dlsym(gles_android,"glGetClipPlanexOES"); disp->set_glGetClipPlanexOES((glGetClipPlanexOES_t)ptr); + ptr = dlsym(gles_android,"glGetFixedvOES"); disp->set_glGetFixedvOES((glGetFixedvOES_t)ptr); + ptr = dlsym(gles_android,"glGetLightxvOES"); disp->set_glGetLightxvOES((glGetLightxvOES_t)ptr); + ptr = dlsym(gles_android,"glGetMaterialxvOES"); disp->set_glGetMaterialxvOES((glGetMaterialxvOES_t)ptr); + ptr = dlsym(gles_android,"glGetTexEnvxvOES"); disp->set_glGetTexEnvxvOES((glGetTexEnvxvOES_t)ptr); + ptr = dlsym(gles_android,"glGetTexParameterxvOES"); disp->set_glGetTexParameterxvOES((glGetTexParameterxvOES_t)ptr); + ptr = dlsym(gles_android,"glLightModelxOES"); disp->set_glLightModelxOES((glLightModelxOES_t)ptr); + ptr = dlsym(gles_android,"glLightModelxvOES"); disp->set_glLightModelxvOES((glLightModelxvOES_t)ptr); + ptr = dlsym(gles_android,"glLightxOES"); disp->set_glLightxOES((glLightxOES_t)ptr); + ptr = dlsym(gles_android,"glLightxvOES"); disp->set_glLightxvOES((glLightxvOES_t)ptr); + ptr = dlsym(gles_android,"glLineWidthxOES"); disp->set_glLineWidthxOES((glLineWidthxOES_t)ptr); + ptr = dlsym(gles_android,"glLoadMatrixxOES"); disp->set_glLoadMatrixxOES((glLoadMatrixxOES_t)ptr); + ptr = dlsym(gles_android,"glMaterialxOES"); disp->set_glMaterialxOES((glMaterialxOES_t)ptr); + ptr = dlsym(gles_android,"glMaterialxvOES"); disp->set_glMaterialxvOES((glMaterialxvOES_t)ptr); + ptr = dlsym(gles_android,"glMultMatrixxOES"); disp->set_glMultMatrixxOES((glMultMatrixxOES_t)ptr); + ptr = dlsym(gles_android,"glMultiTexCoord4xOES"); disp->set_glMultiTexCoord4xOES((glMultiTexCoord4xOES_t)ptr); + ptr = dlsym(gles_android,"glNormal3xOES"); disp->set_glNormal3xOES((glNormal3xOES_t)ptr); + ptr = dlsym(gles_android,"glOrthoxOES"); disp->set_glOrthoxOES((glOrthoxOES_t)ptr); + ptr = dlsym(gles_android,"glPointParameterxOES"); disp->set_glPointParameterxOES((glPointParameterxOES_t)ptr); + ptr = dlsym(gles_android,"glPointParameterxvOES"); disp->set_glPointParameterxvOES((glPointParameterxvOES_t)ptr); + ptr = dlsym(gles_android,"glPointSizexOES"); disp->set_glPointSizexOES((glPointSizexOES_t)ptr); + ptr = dlsym(gles_android,"glPolygonOffsetxOES"); disp->set_glPolygonOffsetxOES((glPolygonOffsetxOES_t)ptr); + ptr = dlsym(gles_android,"glRotatexOES"); disp->set_glRotatexOES((glRotatexOES_t)ptr); + ptr = dlsym(gles_android,"glSampleCoveragexOES"); disp->set_glSampleCoveragexOES((glSampleCoveragexOES_t)ptr); + ptr = dlsym(gles_android,"glScalexOES"); disp->set_glScalexOES((glScalexOES_t)ptr); + ptr = dlsym(gles_android,"glTexEnvxOES"); disp->set_glTexEnvxOES((glTexEnvxOES_t)ptr); + ptr = dlsym(gles_android,"glTexEnvxvOES"); disp->set_glTexEnvxvOES((glTexEnvxvOES_t)ptr); + ptr = dlsym(gles_android,"glTexParameterxOES"); disp->set_glTexParameterxOES((glTexParameterxOES_t)ptr); + ptr = dlsym(gles_android,"glTexParameterxvOES"); disp->set_glTexParameterxvOES((glTexParameterxvOES_t)ptr); + ptr = dlsym(gles_android,"glTranslatexOES"); disp->set_glTranslatexOES((glTranslatexOES_t)ptr); + ptr = dlsym(gles_android,"glIsRenderbufferOES"); disp->set_glIsRenderbufferOES((glIsRenderbufferOES_t)ptr); + ptr = dlsym(gles_android,"glBindRenderbufferOES"); disp->set_glBindRenderbufferOES((glBindRenderbufferOES_t)ptr); + ptr = dlsym(gles_android,"glDeleteRenderbuffersOES"); disp->set_glDeleteRenderbuffersOES((glDeleteRenderbuffersOES_t)ptr); + ptr = dlsym(gles_android,"glGenRenderbuffersOES"); disp->set_glGenRenderbuffersOES((glGenRenderbuffersOES_t)ptr); + ptr = dlsym(gles_android,"glRenderbufferStorageOES"); disp->set_glRenderbufferStorageOES((glRenderbufferStorageOES_t)ptr); + ptr = dlsym(gles_android,"glGetRenderbufferParameterivOES"); disp->set_glGetRenderbufferParameterivOES((glGetRenderbufferParameterivOES_t)ptr); + ptr = dlsym(gles_android,"glIsFramebufferOES"); disp->set_glIsFramebufferOES((glIsFramebufferOES_t)ptr); + ptr = dlsym(gles_android,"glBindFramebufferOES"); disp->set_glBindFramebufferOES((glBindFramebufferOES_t)ptr); + ptr = dlsym(gles_android,"glDeleteFramebuffersOES"); disp->set_glDeleteFramebuffersOES((glDeleteFramebuffersOES_t)ptr); + ptr = dlsym(gles_android,"glGenFramebuffersOES"); disp->set_glGenFramebuffersOES((glGenFramebuffersOES_t)ptr); + ptr = dlsym(gles_android,"glCheckFramebufferStatusOES"); disp->set_glCheckFramebufferStatusOES((glCheckFramebufferStatusOES_t)ptr); + ptr = dlsym(gles_android,"glFramebufferRenderbufferOES"); disp->set_glFramebufferRenderbufferOES((glFramebufferRenderbufferOES_t)ptr); + ptr = dlsym(gles_android,"glFramebufferTexture2DOES"); disp->set_glFramebufferTexture2DOES((glFramebufferTexture2DOES_t)ptr); + ptr = dlsym(gles_android,"glGetFramebufferAttachmentParameterivOES"); disp->set_glGetFramebufferAttachmentParameterivOES((glGetFramebufferAttachmentParameterivOES_t)ptr); + ptr = dlsym(gles_android,"glGenerateMipmapOES"); disp->set_glGenerateMipmapOES((glGenerateMipmapOES_t)ptr); + ptr = dlsym(gles_android,"glMapBufferOES"); disp->set_glMapBufferOES((glMapBufferOES_t)ptr); + ptr = dlsym(gles_android,"glUnmapBufferOES"); disp->set_glUnmapBufferOES((glUnmapBufferOES_t)ptr); + ptr = dlsym(gles_android,"glGetBufferPointervOES"); disp->set_glGetBufferPointervOES((glGetBufferPointervOES_t)ptr); + ptr = dlsym(gles_android,"glCurrentPaletteMatrixOES"); disp->set_glCurrentPaletteMatrixOES((glCurrentPaletteMatrixOES_t)ptr); + ptr = dlsym(gles_android,"glLoadPaletteFromModelViewMatrixOES"); disp->set_glLoadPaletteFromModelViewMatrixOES((glLoadPaletteFromModelViewMatrixOES_t)ptr); + ptr = dlsym(gles_android,"glMatrixIndexPointerOES"); disp->set_glMatrixIndexPointerOES((glMatrixIndexPointerOES_t)ptr); + ptr = dlsym(gles_android,"glWeightPointerOES"); disp->set_glWeightPointerOES((glWeightPointerOES_t)ptr); + ptr = dlsym(gles_android,"glQueryMatrixxOES"); disp->set_glQueryMatrixxOES((glQueryMatrixxOES_t)ptr); + ptr = dlsym(gles_android,"glDepthRangefOES"); disp->set_glDepthRangefOES((glDepthRangefOES_t)ptr); + ptr = dlsym(gles_android,"glFrustumfOES"); disp->set_glFrustumfOES((glFrustumfOES_t)ptr); + ptr = dlsym(gles_android,"glOrthofOES"); disp->set_glOrthofOES((glOrthofOES_t)ptr); + ptr = dlsym(gles_android,"glClipPlanefOES"); disp->set_glClipPlanefOES((glClipPlanefOES_t)ptr); + ptr = dlsym(gles_android,"glGetClipPlanefOES"); disp->set_glGetClipPlanefOES((glGetClipPlanefOES_t)ptr); + ptr = dlsym(gles_android,"glClearDepthfOES"); disp->set_glClearDepthfOES((glClearDepthfOES_t)ptr); + ptr = dlsym(gles_android,"glTexGenfOES"); disp->set_glTexGenfOES((glTexGenfOES_t)ptr); + ptr = dlsym(gles_android,"glTexGenfvOES"); disp->set_glTexGenfvOES((glTexGenfvOES_t)ptr); + ptr = dlsym(gles_android,"glTexGeniOES"); disp->set_glTexGeniOES((glTexGeniOES_t)ptr); + ptr = dlsym(gles_android,"glTexGenivOES"); disp->set_glTexGenivOES((glTexGenivOES_t)ptr); + ptr = dlsym(gles_android,"glTexGenxOES"); disp->set_glTexGenxOES((glTexGenxOES_t)ptr); + ptr = dlsym(gles_android,"glTexGenxvOES"); disp->set_glTexGenxvOES((glTexGenxvOES_t)ptr); + ptr = dlsym(gles_android,"glGetTexGenfvOES"); disp->set_glGetTexGenfvOES((glGetTexGenfvOES_t)ptr); + ptr = dlsym(gles_android,"glGetTexGenivOES"); disp->set_glGetTexGenivOES((glGetTexGenivOES_t)ptr); + ptr = dlsym(gles_android,"glGetTexGenxvOES"); disp->set_glGetTexGenxvOES((glGetTexGenxvOES_t)ptr); + ptr = dlsym(gles_android,"glBindVertexArrayOES"); disp->set_glBindVertexArrayOES((glBindVertexArrayOES_t)ptr); + ptr = dlsym(gles_android,"glDeleteVertexArraysOES"); disp->set_glDeleteVertexArraysOES((glDeleteVertexArraysOES_t)ptr); + ptr = dlsym(gles_android,"glGenVertexArraysOES"); disp->set_glGenVertexArraysOES((glGenVertexArraysOES_t)ptr); + ptr = dlsym(gles_android,"glIsVertexArrayOES"); disp->set_glIsVertexArrayOES((glIsVertexArrayOES_t)ptr); + ptr = dlsym(gles_android,"glDiscardFramebufferEXT"); disp->set_glDiscardFramebufferEXT((glDiscardFramebufferEXT_t)ptr); + ptr = dlsym(gles_android,"glMultiDrawArraysEXT"); disp->set_glMultiDrawArraysEXT((glMultiDrawArraysEXT_t)ptr); + ptr = dlsym(gles_android,"glMultiDrawElementsEXT"); disp->set_glMultiDrawElementsEXT((glMultiDrawElementsEXT_t)ptr); + ptr = dlsym(gles_android,"glClipPlanefIMG"); disp->set_glClipPlanefIMG((glClipPlanefIMG_t)ptr); + ptr = dlsym(gles_android,"glClipPlanexIMG"); disp->set_glClipPlanexIMG((glClipPlanexIMG_t)ptr); + ptr = dlsym(gles_android,"glRenderbufferStorageMultisampleIMG"); disp->set_glRenderbufferStorageMultisampleIMG((glRenderbufferStorageMultisampleIMG_t)ptr); + ptr = dlsym(gles_android,"glFramebufferTexture2DMultisampleIMG"); disp->set_glFramebufferTexture2DMultisampleIMG((glFramebufferTexture2DMultisampleIMG_t)ptr); + ptr = dlsym(gles_android,"glDeleteFencesNV"); disp->set_glDeleteFencesNV((glDeleteFencesNV_t)ptr); + ptr = dlsym(gles_android,"glGenFencesNV"); disp->set_glGenFencesNV((glGenFencesNV_t)ptr); + ptr = dlsym(gles_android,"glIsFenceNV"); disp->set_glIsFenceNV((glIsFenceNV_t)ptr); + ptr = dlsym(gles_android,"glTestFenceNV"); disp->set_glTestFenceNV((glTestFenceNV_t)ptr); + ptr = dlsym(gles_android,"glGetFenceivNV"); disp->set_glGetFenceivNV((glGetFenceivNV_t)ptr); + ptr = dlsym(gles_android,"glFinishFenceNV"); disp->set_glFinishFenceNV((glFinishFenceNV_t)ptr); + ptr = dlsym(gles_android,"glSetFenceNV"); disp->set_glSetFenceNV((glSetFenceNV_t)ptr); + ptr = dlsym(gles_android,"glGetDriverControlsQCOM"); disp->set_glGetDriverControlsQCOM((glGetDriverControlsQCOM_t)ptr); + ptr = dlsym(gles_android,"glGetDriverControlStringQCOM"); disp->set_glGetDriverControlStringQCOM((glGetDriverControlStringQCOM_t)ptr); + ptr = dlsym(gles_android,"glEnableDriverControlQCOM"); disp->set_glEnableDriverControlQCOM((glEnableDriverControlQCOM_t)ptr); + ptr = dlsym(gles_android,"glDisableDriverControlQCOM"); disp->set_glDisableDriverControlQCOM((glDisableDriverControlQCOM_t)ptr); + ptr = dlsym(gles_android,"glExtGetTexturesQCOM"); disp->set_glExtGetTexturesQCOM((glExtGetTexturesQCOM_t)ptr); + ptr = dlsym(gles_android,"glExtGetBuffersQCOM"); disp->set_glExtGetBuffersQCOM((glExtGetBuffersQCOM_t)ptr); + ptr = dlsym(gles_android,"glExtGetRenderbuffersQCOM"); disp->set_glExtGetRenderbuffersQCOM((glExtGetRenderbuffersQCOM_t)ptr); + ptr = dlsym(gles_android,"glExtGetFramebuffersQCOM"); disp->set_glExtGetFramebuffersQCOM((glExtGetFramebuffersQCOM_t)ptr); + ptr = dlsym(gles_android,"glExtGetTexLevelParameterivQCOM"); disp->set_glExtGetTexLevelParameterivQCOM((glExtGetTexLevelParameterivQCOM_t)ptr); + ptr = dlsym(gles_android,"glExtTexObjectStateOverrideiQCOM"); disp->set_glExtTexObjectStateOverrideiQCOM((glExtTexObjectStateOverrideiQCOM_t)ptr); + ptr = dlsym(gles_android,"glExtGetTexSubImageQCOM"); disp->set_glExtGetTexSubImageQCOM((glExtGetTexSubImageQCOM_t)ptr); + ptr = dlsym(gles_android,"glExtGetBufferPointervQCOM"); disp->set_glExtGetBufferPointervQCOM((glExtGetBufferPointervQCOM_t)ptr); + ptr = dlsym(gles_android,"glExtGetShadersQCOM"); disp->set_glExtGetShadersQCOM((glExtGetShadersQCOM_t)ptr); + ptr = dlsym(gles_android,"glExtGetProgramsQCOM"); disp->set_glExtGetProgramsQCOM((glExtGetProgramsQCOM_t)ptr); + ptr = dlsym(gles_android,"glExtIsProgramBinaryQCOM"); disp->set_glExtIsProgramBinaryQCOM((glExtIsProgramBinaryQCOM_t)ptr); + ptr = dlsym(gles_android,"glExtGetProgramBinarySourceQCOM"); disp->set_glExtGetProgramBinarySourceQCOM((glExtGetProgramBinarySourceQCOM_t)ptr); + ptr = dlsym(gles_android,"glStartTilingQCOM"); disp->set_glStartTilingQCOM((glStartTilingQCOM_t)ptr); + ptr = dlsym(gles_android,"glEndTilingQCOM"); disp->set_glEndTilingQCOM((glEndTilingQCOM_t)ptr); + + return disp; +} diff --git a/emulator/opengl/tests/gles_android_wrapper/gles_dispatch.h b/emulator/opengl/tests/gles_android_wrapper/gles_dispatch.h new file mode 100644 index 0000000..98a4fca --- /dev/null +++ b/emulator/opengl/tests/gles_android_wrapper/gles_dispatch.h @@ -0,0 +1,570 @@ +/* +* Copyright (C) 2011 The Android Open Source Project +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ +#ifndef _GLES_DISPATCH_H +#define _GLES_DISPATCH_H + +#include "gles_proc.h" + + +struct gles_dispatch { + glAlphaFunc_t glAlphaFunc; + glClearColor_t glClearColor; + glClearDepthf_t glClearDepthf; + glClipPlanef_t glClipPlanef; + glColor4f_t glColor4f; + glDepthRangef_t glDepthRangef; + glFogf_t glFogf; + glFogfv_t glFogfv; + glFrustumf_t glFrustumf; + glGetClipPlanef_t glGetClipPlanef; + glGetFloatv_t glGetFloatv; + glGetLightfv_t glGetLightfv; + glGetMaterialfv_t glGetMaterialfv; + glGetTexEnvfv_t glGetTexEnvfv; + glGetTexParameterfv_t glGetTexParameterfv; + glLightModelf_t glLightModelf; + glLightModelfv_t glLightModelfv; + glLightf_t glLightf; + glLightfv_t glLightfv; + glLineWidth_t glLineWidth; + glLoadMatrixf_t glLoadMatrixf; + glMaterialf_t glMaterialf; + glMaterialfv_t glMaterialfv; + glMultMatrixf_t glMultMatrixf; + glMultiTexCoord4f_t glMultiTexCoord4f; + glNormal3f_t glNormal3f; + glOrthof_t glOrthof; + glPointParameterf_t glPointParameterf; + glPointParameterfv_t glPointParameterfv; + glPointSize_t glPointSize; + glPolygonOffset_t glPolygonOffset; + glRotatef_t glRotatef; + glScalef_t glScalef; + glTexEnvf_t glTexEnvf; + glTexEnvfv_t glTexEnvfv; + glTexParameterf_t glTexParameterf; + glTexParameterfv_t glTexParameterfv; + glTranslatef_t glTranslatef; + glActiveTexture_t glActiveTexture; + glAlphaFuncx_t glAlphaFuncx; + glBindBuffer_t glBindBuffer; + glBindTexture_t glBindTexture; + glBlendFunc_t glBlendFunc; + glBufferData_t glBufferData; + glBufferSubData_t glBufferSubData; + glClear_t glClear; + glClearColorx_t glClearColorx; + glClearDepthx_t glClearDepthx; + glClearStencil_t glClearStencil; + glClientActiveTexture_t glClientActiveTexture; + glClipPlanex_t glClipPlanex; + glColor4ub_t glColor4ub; + glColor4x_t glColor4x; + glColorMask_t glColorMask; + glColorPointer_t glColorPointer; + glCompressedTexImage2D_t glCompressedTexImage2D; + glCompressedTexSubImage2D_t glCompressedTexSubImage2D; + glCopyTexImage2D_t glCopyTexImage2D; + glCopyTexSubImage2D_t glCopyTexSubImage2D; + glCullFace_t glCullFace; + glDeleteBuffers_t glDeleteBuffers; + glDeleteTextures_t glDeleteTextures; + glDepthFunc_t glDepthFunc; + glDepthMask_t glDepthMask; + glDepthRangex_t glDepthRangex; + glDisable_t glDisable; + glDisableClientState_t glDisableClientState; + glDrawArrays_t glDrawArrays; + glDrawElements_t glDrawElements; + glEnable_t glEnable; + glEnableClientState_t glEnableClientState; + glFinish_t glFinish; + glFlush_t glFlush; + glFogx_t glFogx; + glFogxv_t glFogxv; + glFrontFace_t glFrontFace; + glFrustumx_t glFrustumx; + glGetBooleanv_t glGetBooleanv; + glGetBufferParameteriv_t glGetBufferParameteriv; + glGetClipPlanex_t glGetClipPlanex; + glGenBuffers_t glGenBuffers; + glGenTextures_t glGenTextures; + glGetError_t glGetError; + glGetFixedv_t glGetFixedv; + glGetIntegerv_t glGetIntegerv; + glGetLightxv_t glGetLightxv; + glGetMaterialxv_t glGetMaterialxv; + glGetPointerv_t glGetPointerv; + glGetString_t glGetString; + glGetTexEnviv_t glGetTexEnviv; + glGetTexEnvxv_t glGetTexEnvxv; + glGetTexParameteriv_t glGetTexParameteriv; + glGetTexParameterxv_t glGetTexParameterxv; + glHint_t glHint; + glIsBuffer_t glIsBuffer; + glIsEnabled_t glIsEnabled; + glIsTexture_t glIsTexture; + glLightModelx_t glLightModelx; + glLightModelxv_t glLightModelxv; + glLightx_t glLightx; + glLightxv_t glLightxv; + glLineWidthx_t glLineWidthx; + glLoadIdentity_t glLoadIdentity; + glLoadMatrixx_t glLoadMatrixx; + glLogicOp_t glLogicOp; + glMaterialx_t glMaterialx; + glMaterialxv_t glMaterialxv; + glMatrixMode_t glMatrixMode; + glMultMatrixx_t glMultMatrixx; + glMultiTexCoord4x_t glMultiTexCoord4x; + glNormal3x_t glNormal3x; + glNormalPointer_t glNormalPointer; + glOrthox_t glOrthox; + glPixelStorei_t glPixelStorei; + glPointParameterx_t glPointParameterx; + glPointParameterxv_t glPointParameterxv; + glPointSizex_t glPointSizex; + glPolygonOffsetx_t glPolygonOffsetx; + glPopMatrix_t glPopMatrix; + glPushMatrix_t glPushMatrix; + glReadPixels_t glReadPixels; + glRotatex_t glRotatex; + glSampleCoverage_t glSampleCoverage; + glSampleCoveragex_t glSampleCoveragex; + glScalex_t glScalex; + glScissor_t glScissor; + glShadeModel_t glShadeModel; + glStencilFunc_t glStencilFunc; + glStencilMask_t glStencilMask; + glStencilOp_t glStencilOp; + glTexCoordPointer_t glTexCoordPointer; + glTexEnvi_t glTexEnvi; + glTexEnvx_t glTexEnvx; + glTexEnviv_t glTexEnviv; + glTexEnvxv_t glTexEnvxv; + glTexImage2D_t glTexImage2D; + glTexParameteri_t glTexParameteri; + glTexParameterx_t glTexParameterx; + glTexParameteriv_t glTexParameteriv; + glTexParameterxv_t glTexParameterxv; + glTexSubImage2D_t glTexSubImage2D; + glTranslatex_t glTranslatex; + glVertexPointer_t glVertexPointer; + glViewport_t glViewport; + glPointSizePointerOES_t glPointSizePointerOES; + glBlendEquationSeparateOES_t glBlendEquationSeparateOES; + glBlendFuncSeparateOES_t glBlendFuncSeparateOES; + glBlendEquationOES_t glBlendEquationOES; + glDrawTexsOES_t glDrawTexsOES; + glDrawTexiOES_t glDrawTexiOES; + glDrawTexxOES_t glDrawTexxOES; + glDrawTexsvOES_t glDrawTexsvOES; + glDrawTexivOES_t glDrawTexivOES; + glDrawTexxvOES_t glDrawTexxvOES; + glDrawTexfOES_t glDrawTexfOES; + glDrawTexfvOES_t glDrawTexfvOES; + glEGLImageTargetTexture2DOES_t glEGLImageTargetTexture2DOES; + glEGLImageTargetRenderbufferStorageOES_t glEGLImageTargetRenderbufferStorageOES; + glAlphaFuncxOES_t glAlphaFuncxOES; + glClearColorxOES_t glClearColorxOES; + glClearDepthxOES_t glClearDepthxOES; + glClipPlanexOES_t glClipPlanexOES; + glColor4xOES_t glColor4xOES; + glDepthRangexOES_t glDepthRangexOES; + glFogxOES_t glFogxOES; + glFogxvOES_t glFogxvOES; + glFrustumxOES_t glFrustumxOES; + glGetClipPlanexOES_t glGetClipPlanexOES; + glGetFixedvOES_t glGetFixedvOES; + glGetLightxvOES_t glGetLightxvOES; + glGetMaterialxvOES_t glGetMaterialxvOES; + glGetTexEnvxvOES_t glGetTexEnvxvOES; + glGetTexParameterxvOES_t glGetTexParameterxvOES; + glLightModelxOES_t glLightModelxOES; + glLightModelxvOES_t glLightModelxvOES; + glLightxOES_t glLightxOES; + glLightxvOES_t glLightxvOES; + glLineWidthxOES_t glLineWidthxOES; + glLoadMatrixxOES_t glLoadMatrixxOES; + glMaterialxOES_t glMaterialxOES; + glMaterialxvOES_t glMaterialxvOES; + glMultMatrixxOES_t glMultMatrixxOES; + glMultiTexCoord4xOES_t glMultiTexCoord4xOES; + glNormal3xOES_t glNormal3xOES; + glOrthoxOES_t glOrthoxOES; + glPointParameterxOES_t glPointParameterxOES; + glPointParameterxvOES_t glPointParameterxvOES; + glPointSizexOES_t glPointSizexOES; + glPolygonOffsetxOES_t glPolygonOffsetxOES; + glRotatexOES_t glRotatexOES; + glSampleCoveragexOES_t glSampleCoveragexOES; + glScalexOES_t glScalexOES; + glTexEnvxOES_t glTexEnvxOES; + glTexEnvxvOES_t glTexEnvxvOES; + glTexParameterxOES_t glTexParameterxOES; + glTexParameterxvOES_t glTexParameterxvOES; + glTranslatexOES_t glTranslatexOES; + glIsRenderbufferOES_t glIsRenderbufferOES; + glBindRenderbufferOES_t glBindRenderbufferOES; + glDeleteRenderbuffersOES_t glDeleteRenderbuffersOES; + glGenRenderbuffersOES_t glGenRenderbuffersOES; + glRenderbufferStorageOES_t glRenderbufferStorageOES; + glGetRenderbufferParameterivOES_t glGetRenderbufferParameterivOES; + glIsFramebufferOES_t glIsFramebufferOES; + glBindFramebufferOES_t glBindFramebufferOES; + glDeleteFramebuffersOES_t glDeleteFramebuffersOES; + glGenFramebuffersOES_t glGenFramebuffersOES; + glCheckFramebufferStatusOES_t glCheckFramebufferStatusOES; + glFramebufferRenderbufferOES_t glFramebufferRenderbufferOES; + glFramebufferTexture2DOES_t glFramebufferTexture2DOES; + glGetFramebufferAttachmentParameterivOES_t glGetFramebufferAttachmentParameterivOES; + glGenerateMipmapOES_t glGenerateMipmapOES; + glMapBufferOES_t glMapBufferOES; + glUnmapBufferOES_t glUnmapBufferOES; + glGetBufferPointervOES_t glGetBufferPointervOES; + glCurrentPaletteMatrixOES_t glCurrentPaletteMatrixOES; + glLoadPaletteFromModelViewMatrixOES_t glLoadPaletteFromModelViewMatrixOES; + glMatrixIndexPointerOES_t glMatrixIndexPointerOES; + glWeightPointerOES_t glWeightPointerOES; + glQueryMatrixxOES_t glQueryMatrixxOES; + glDepthRangefOES_t glDepthRangefOES; + glFrustumfOES_t glFrustumfOES; + glOrthofOES_t glOrthofOES; + glClipPlanefOES_t glClipPlanefOES; + glGetClipPlanefOES_t glGetClipPlanefOES; + glClearDepthfOES_t glClearDepthfOES; + glTexGenfOES_t glTexGenfOES; + glTexGenfvOES_t glTexGenfvOES; + glTexGeniOES_t glTexGeniOES; + glTexGenivOES_t glTexGenivOES; + glTexGenxOES_t glTexGenxOES; + glTexGenxvOES_t glTexGenxvOES; + glGetTexGenfvOES_t glGetTexGenfvOES; + glGetTexGenivOES_t glGetTexGenivOES; + glGetTexGenxvOES_t glGetTexGenxvOES; + glBindVertexArrayOES_t glBindVertexArrayOES; + glDeleteVertexArraysOES_t glDeleteVertexArraysOES; + glGenVertexArraysOES_t glGenVertexArraysOES; + glIsVertexArrayOES_t glIsVertexArrayOES; + glDiscardFramebufferEXT_t glDiscardFramebufferEXT; + glMultiDrawArraysEXT_t glMultiDrawArraysEXT; + glMultiDrawElementsEXT_t glMultiDrawElementsEXT; + glClipPlanefIMG_t glClipPlanefIMG; + glClipPlanexIMG_t glClipPlanexIMG; + glRenderbufferStorageMultisampleIMG_t glRenderbufferStorageMultisampleIMG; + glFramebufferTexture2DMultisampleIMG_t glFramebufferTexture2DMultisampleIMG; + glDeleteFencesNV_t glDeleteFencesNV; + glGenFencesNV_t glGenFencesNV; + glIsFenceNV_t glIsFenceNV; + glTestFenceNV_t glTestFenceNV; + glGetFenceivNV_t glGetFenceivNV; + glFinishFenceNV_t glFinishFenceNV; + glSetFenceNV_t glSetFenceNV; + glGetDriverControlsQCOM_t glGetDriverControlsQCOM; + glGetDriverControlStringQCOM_t glGetDriverControlStringQCOM; + glEnableDriverControlQCOM_t glEnableDriverControlQCOM; + glDisableDriverControlQCOM_t glDisableDriverControlQCOM; + glExtGetTexturesQCOM_t glExtGetTexturesQCOM; + glExtGetBuffersQCOM_t glExtGetBuffersQCOM; + glExtGetRenderbuffersQCOM_t glExtGetRenderbuffersQCOM; + glExtGetFramebuffersQCOM_t glExtGetFramebuffersQCOM; + glExtGetTexLevelParameterivQCOM_t glExtGetTexLevelParameterivQCOM; + glExtTexObjectStateOverrideiQCOM_t glExtTexObjectStateOverrideiQCOM; + glExtGetTexSubImageQCOM_t glExtGetTexSubImageQCOM; + glExtGetBufferPointervQCOM_t glExtGetBufferPointervQCOM; + glExtGetShadersQCOM_t glExtGetShadersQCOM; + glExtGetProgramsQCOM_t glExtGetProgramsQCOM; + glExtIsProgramBinaryQCOM_t glExtIsProgramBinaryQCOM; + glExtGetProgramBinarySourceQCOM_t glExtGetProgramBinarySourceQCOM; + glStartTilingQCOM_t glStartTilingQCOM; + glEndTilingQCOM_t glEndTilingQCOM; + //Accessors + glAlphaFunc_t set_glAlphaFunc(glAlphaFunc_t f) { glAlphaFunc_t retval = glAlphaFunc; glAlphaFunc = f; return retval;} + glClearColor_t set_glClearColor(glClearColor_t f) { glClearColor_t retval = glClearColor; glClearColor = f; return retval;} + glClearDepthf_t set_glClearDepthf(glClearDepthf_t f) { glClearDepthf_t retval = glClearDepthf; glClearDepthf = f; return retval;} + glClipPlanef_t set_glClipPlanef(glClipPlanef_t f) { glClipPlanef_t retval = glClipPlanef; glClipPlanef = f; return retval;} + glColor4f_t set_glColor4f(glColor4f_t f) { glColor4f_t retval = glColor4f; glColor4f = f; return retval;} + glDepthRangef_t set_glDepthRangef(glDepthRangef_t f) { glDepthRangef_t retval = glDepthRangef; glDepthRangef = f; return retval;} + glFogf_t set_glFogf(glFogf_t f) { glFogf_t retval = glFogf; glFogf = f; return retval;} + glFogfv_t set_glFogfv(glFogfv_t f) { glFogfv_t retval = glFogfv; glFogfv = f; return retval;} + glFrustumf_t set_glFrustumf(glFrustumf_t f) { glFrustumf_t retval = glFrustumf; glFrustumf = f; return retval;} + glGetClipPlanef_t set_glGetClipPlanef(glGetClipPlanef_t f) { glGetClipPlanef_t retval = glGetClipPlanef; glGetClipPlanef = f; return retval;} + glGetFloatv_t set_glGetFloatv(glGetFloatv_t f) { glGetFloatv_t retval = glGetFloatv; glGetFloatv = f; return retval;} + glGetLightfv_t set_glGetLightfv(glGetLightfv_t f) { glGetLightfv_t retval = glGetLightfv; glGetLightfv = f; return retval;} + glGetMaterialfv_t set_glGetMaterialfv(glGetMaterialfv_t f) { glGetMaterialfv_t retval = glGetMaterialfv; glGetMaterialfv = f; return retval;} + glGetTexEnvfv_t set_glGetTexEnvfv(glGetTexEnvfv_t f) { glGetTexEnvfv_t retval = glGetTexEnvfv; glGetTexEnvfv = f; return retval;} + glGetTexParameterfv_t set_glGetTexParameterfv(glGetTexParameterfv_t f) { glGetTexParameterfv_t retval = glGetTexParameterfv; glGetTexParameterfv = f; return retval;} + glLightModelf_t set_glLightModelf(glLightModelf_t f) { glLightModelf_t retval = glLightModelf; glLightModelf = f; return retval;} + glLightModelfv_t set_glLightModelfv(glLightModelfv_t f) { glLightModelfv_t retval = glLightModelfv; glLightModelfv = f; return retval;} + glLightf_t set_glLightf(glLightf_t f) { glLightf_t retval = glLightf; glLightf = f; return retval;} + glLightfv_t set_glLightfv(glLightfv_t f) { glLightfv_t retval = glLightfv; glLightfv = f; return retval;} + glLineWidth_t set_glLineWidth(glLineWidth_t f) { glLineWidth_t retval = glLineWidth; glLineWidth = f; return retval;} + glLoadMatrixf_t set_glLoadMatrixf(glLoadMatrixf_t f) { glLoadMatrixf_t retval = glLoadMatrixf; glLoadMatrixf = f; return retval;} + glMaterialf_t set_glMaterialf(glMaterialf_t f) { glMaterialf_t retval = glMaterialf; glMaterialf = f; return retval;} + glMaterialfv_t set_glMaterialfv(glMaterialfv_t f) { glMaterialfv_t retval = glMaterialfv; glMaterialfv = f; return retval;} + glMultMatrixf_t set_glMultMatrixf(glMultMatrixf_t f) { glMultMatrixf_t retval = glMultMatrixf; glMultMatrixf = f; return retval;} + glMultiTexCoord4f_t set_glMultiTexCoord4f(glMultiTexCoord4f_t f) { glMultiTexCoord4f_t retval = glMultiTexCoord4f; glMultiTexCoord4f = f; return retval;} + glNormal3f_t set_glNormal3f(glNormal3f_t f) { glNormal3f_t retval = glNormal3f; glNormal3f = f; return retval;} + glOrthof_t set_glOrthof(glOrthof_t f) { glOrthof_t retval = glOrthof; glOrthof = f; return retval;} + glPointParameterf_t set_glPointParameterf(glPointParameterf_t f) { glPointParameterf_t retval = glPointParameterf; glPointParameterf = f; return retval;} + glPointParameterfv_t set_glPointParameterfv(glPointParameterfv_t f) { glPointParameterfv_t retval = glPointParameterfv; glPointParameterfv = f; return retval;} + glPointSize_t set_glPointSize(glPointSize_t f) { glPointSize_t retval = glPointSize; glPointSize = f; return retval;} + glPolygonOffset_t set_glPolygonOffset(glPolygonOffset_t f) { glPolygonOffset_t retval = glPolygonOffset; glPolygonOffset = f; return retval;} + glRotatef_t set_glRotatef(glRotatef_t f) { glRotatef_t retval = glRotatef; glRotatef = f; return retval;} + glScalef_t set_glScalef(glScalef_t f) { glScalef_t retval = glScalef; glScalef = f; return retval;} + glTexEnvf_t set_glTexEnvf(glTexEnvf_t f) { glTexEnvf_t retval = glTexEnvf; glTexEnvf = f; return retval;} + glTexEnvfv_t set_glTexEnvfv(glTexEnvfv_t f) { glTexEnvfv_t retval = glTexEnvfv; glTexEnvfv = f; return retval;} + glTexParameterf_t set_glTexParameterf(glTexParameterf_t f) { glTexParameterf_t retval = glTexParameterf; glTexParameterf = f; return retval;} + glTexParameterfv_t set_glTexParameterfv(glTexParameterfv_t f) { glTexParameterfv_t retval = glTexParameterfv; glTexParameterfv = f; return retval;} + glTranslatef_t set_glTranslatef(glTranslatef_t f) { glTranslatef_t retval = glTranslatef; glTranslatef = f; return retval;} + glActiveTexture_t set_glActiveTexture(glActiveTexture_t f) { glActiveTexture_t retval = glActiveTexture; glActiveTexture = f; return retval;} + glAlphaFuncx_t set_glAlphaFuncx(glAlphaFuncx_t f) { glAlphaFuncx_t retval = glAlphaFuncx; glAlphaFuncx = f; return retval;} + glBindBuffer_t set_glBindBuffer(glBindBuffer_t f) { glBindBuffer_t retval = glBindBuffer; glBindBuffer = f; return retval;} + glBindTexture_t set_glBindTexture(glBindTexture_t f) { glBindTexture_t retval = glBindTexture; glBindTexture = f; return retval;} + glBlendFunc_t set_glBlendFunc(glBlendFunc_t f) { glBlendFunc_t retval = glBlendFunc; glBlendFunc = f; return retval;} + glBufferData_t set_glBufferData(glBufferData_t f) { glBufferData_t retval = glBufferData; glBufferData = f; return retval;} + glBufferSubData_t set_glBufferSubData(glBufferSubData_t f) { glBufferSubData_t retval = glBufferSubData; glBufferSubData = f; return retval;} + glClear_t set_glClear(glClear_t f) { glClear_t retval = glClear; glClear = f; return retval;} + glClearColorx_t set_glClearColorx(glClearColorx_t f) { glClearColorx_t retval = glClearColorx; glClearColorx = f; return retval;} + glClearDepthx_t set_glClearDepthx(glClearDepthx_t f) { glClearDepthx_t retval = glClearDepthx; glClearDepthx = f; return retval;} + glClearStencil_t set_glClearStencil(glClearStencil_t f) { glClearStencil_t retval = glClearStencil; glClearStencil = f; return retval;} + glClientActiveTexture_t set_glClientActiveTexture(glClientActiveTexture_t f) { glClientActiveTexture_t retval = glClientActiveTexture; glClientActiveTexture = f; return retval;} + glClipPlanex_t set_glClipPlanex(glClipPlanex_t f) { glClipPlanex_t retval = glClipPlanex; glClipPlanex = f; return retval;} + glColor4ub_t set_glColor4ub(glColor4ub_t f) { glColor4ub_t retval = glColor4ub; glColor4ub = f; return retval;} + glColor4x_t set_glColor4x(glColor4x_t f) { glColor4x_t retval = glColor4x; glColor4x = f; return retval;} + glColorMask_t set_glColorMask(glColorMask_t f) { glColorMask_t retval = glColorMask; glColorMask = f; return retval;} + glColorPointer_t set_glColorPointer(glColorPointer_t f) { glColorPointer_t retval = glColorPointer; glColorPointer = f; return retval;} + glCompressedTexImage2D_t set_glCompressedTexImage2D(glCompressedTexImage2D_t f) { glCompressedTexImage2D_t retval = glCompressedTexImage2D; glCompressedTexImage2D = f; return retval;} + glCompressedTexSubImage2D_t set_glCompressedTexSubImage2D(glCompressedTexSubImage2D_t f) { glCompressedTexSubImage2D_t retval = glCompressedTexSubImage2D; glCompressedTexSubImage2D = f; return retval;} + glCopyTexImage2D_t set_glCopyTexImage2D(glCopyTexImage2D_t f) { glCopyTexImage2D_t retval = glCopyTexImage2D; glCopyTexImage2D = f; return retval;} + glCopyTexSubImage2D_t set_glCopyTexSubImage2D(glCopyTexSubImage2D_t f) { glCopyTexSubImage2D_t retval = glCopyTexSubImage2D; glCopyTexSubImage2D = f; return retval;} + glCullFace_t set_glCullFace(glCullFace_t f) { glCullFace_t retval = glCullFace; glCullFace = f; return retval;} + glDeleteBuffers_t set_glDeleteBuffers(glDeleteBuffers_t f) { glDeleteBuffers_t retval = glDeleteBuffers; glDeleteBuffers = f; return retval;} + glDeleteTextures_t set_glDeleteTextures(glDeleteTextures_t f) { glDeleteTextures_t retval = glDeleteTextures; glDeleteTextures = f; return retval;} + glDepthFunc_t set_glDepthFunc(glDepthFunc_t f) { glDepthFunc_t retval = glDepthFunc; glDepthFunc = f; return retval;} + glDepthMask_t set_glDepthMask(glDepthMask_t f) { glDepthMask_t retval = glDepthMask; glDepthMask = f; return retval;} + glDepthRangex_t set_glDepthRangex(glDepthRangex_t f) { glDepthRangex_t retval = glDepthRangex; glDepthRangex = f; return retval;} + glDisable_t set_glDisable(glDisable_t f) { glDisable_t retval = glDisable; glDisable = f; return retval;} + glDisableClientState_t set_glDisableClientState(glDisableClientState_t f) { glDisableClientState_t retval = glDisableClientState; glDisableClientState = f; return retval;} + glDrawArrays_t set_glDrawArrays(glDrawArrays_t f) { glDrawArrays_t retval = glDrawArrays; glDrawArrays = f; return retval;} + glDrawElements_t set_glDrawElements(glDrawElements_t f) { glDrawElements_t retval = glDrawElements; glDrawElements = f; return retval;} + glEnable_t set_glEnable(glEnable_t f) { glEnable_t retval = glEnable; glEnable = f; return retval;} + glEnableClientState_t set_glEnableClientState(glEnableClientState_t f) { glEnableClientState_t retval = glEnableClientState; glEnableClientState = f; return retval;} + glFinish_t set_glFinish(glFinish_t f) { glFinish_t retval = glFinish; glFinish = f; return retval;} + glFlush_t set_glFlush(glFlush_t f) { glFlush_t retval = glFlush; glFlush = f; return retval;} + glFogx_t set_glFogx(glFogx_t f) { glFogx_t retval = glFogx; glFogx = f; return retval;} + glFogxv_t set_glFogxv(glFogxv_t f) { glFogxv_t retval = glFogxv; glFogxv = f; return retval;} + glFrontFace_t set_glFrontFace(glFrontFace_t f) { glFrontFace_t retval = glFrontFace; glFrontFace = f; return retval;} + glFrustumx_t set_glFrustumx(glFrustumx_t f) { glFrustumx_t retval = glFrustumx; glFrustumx = f; return retval;} + glGetBooleanv_t set_glGetBooleanv(glGetBooleanv_t f) { glGetBooleanv_t retval = glGetBooleanv; glGetBooleanv = f; return retval;} + glGetBufferParameteriv_t set_glGetBufferParameteriv(glGetBufferParameteriv_t f) { glGetBufferParameteriv_t retval = glGetBufferParameteriv; glGetBufferParameteriv = f; return retval;} + glGetClipPlanex_t set_glGetClipPlanex(glGetClipPlanex_t f) { glGetClipPlanex_t retval = glGetClipPlanex; glGetClipPlanex = f; return retval;} + glGenBuffers_t set_glGenBuffers(glGenBuffers_t f) { glGenBuffers_t retval = glGenBuffers; glGenBuffers = f; return retval;} + glGenTextures_t set_glGenTextures(glGenTextures_t f) { glGenTextures_t retval = glGenTextures; glGenTextures = f; return retval;} + glGetError_t set_glGetError(glGetError_t f) { glGetError_t retval = glGetError; glGetError = f; return retval;} + glGetFixedv_t set_glGetFixedv(glGetFixedv_t f) { glGetFixedv_t retval = glGetFixedv; glGetFixedv = f; return retval;} + glGetIntegerv_t set_glGetIntegerv(glGetIntegerv_t f) { glGetIntegerv_t retval = glGetIntegerv; glGetIntegerv = f; return retval;} + glGetLightxv_t set_glGetLightxv(glGetLightxv_t f) { glGetLightxv_t retval = glGetLightxv; glGetLightxv = f; return retval;} + glGetMaterialxv_t set_glGetMaterialxv(glGetMaterialxv_t f) { glGetMaterialxv_t retval = glGetMaterialxv; glGetMaterialxv = f; return retval;} + glGetPointerv_t set_glGetPointerv(glGetPointerv_t f) { glGetPointerv_t retval = glGetPointerv; glGetPointerv = f; return retval;} + glGetString_t set_glGetString(glGetString_t f) { glGetString_t retval = glGetString; glGetString = f; return retval;} + glGetTexEnviv_t set_glGetTexEnviv(glGetTexEnviv_t f) { glGetTexEnviv_t retval = glGetTexEnviv; glGetTexEnviv = f; return retval;} + glGetTexEnvxv_t set_glGetTexEnvxv(glGetTexEnvxv_t f) { glGetTexEnvxv_t retval = glGetTexEnvxv; glGetTexEnvxv = f; return retval;} + glGetTexParameteriv_t set_glGetTexParameteriv(glGetTexParameteriv_t f) { glGetTexParameteriv_t retval = glGetTexParameteriv; glGetTexParameteriv = f; return retval;} + glGetTexParameterxv_t set_glGetTexParameterxv(glGetTexParameterxv_t f) { glGetTexParameterxv_t retval = glGetTexParameterxv; glGetTexParameterxv = f; return retval;} + glHint_t set_glHint(glHint_t f) { glHint_t retval = glHint; glHint = f; return retval;} + glIsBuffer_t set_glIsBuffer(glIsBuffer_t f) { glIsBuffer_t retval = glIsBuffer; glIsBuffer = f; return retval;} + glIsEnabled_t set_glIsEnabled(glIsEnabled_t f) { glIsEnabled_t retval = glIsEnabled; glIsEnabled = f; return retval;} + glIsTexture_t set_glIsTexture(glIsTexture_t f) { glIsTexture_t retval = glIsTexture; glIsTexture = f; return retval;} + glLightModelx_t set_glLightModelx(glLightModelx_t f) { glLightModelx_t retval = glLightModelx; glLightModelx = f; return retval;} + glLightModelxv_t set_glLightModelxv(glLightModelxv_t f) { glLightModelxv_t retval = glLightModelxv; glLightModelxv = f; return retval;} + glLightx_t set_glLightx(glLightx_t f) { glLightx_t retval = glLightx; glLightx = f; return retval;} + glLightxv_t set_glLightxv(glLightxv_t f) { glLightxv_t retval = glLightxv; glLightxv = f; return retval;} + glLineWidthx_t set_glLineWidthx(glLineWidthx_t f) { glLineWidthx_t retval = glLineWidthx; glLineWidthx = f; return retval;} + glLoadIdentity_t set_glLoadIdentity(glLoadIdentity_t f) { glLoadIdentity_t retval = glLoadIdentity; glLoadIdentity = f; return retval;} + glLoadMatrixx_t set_glLoadMatrixx(glLoadMatrixx_t f) { glLoadMatrixx_t retval = glLoadMatrixx; glLoadMatrixx = f; return retval;} + glLogicOp_t set_glLogicOp(glLogicOp_t f) { glLogicOp_t retval = glLogicOp; glLogicOp = f; return retval;} + glMaterialx_t set_glMaterialx(glMaterialx_t f) { glMaterialx_t retval = glMaterialx; glMaterialx = f; return retval;} + glMaterialxv_t set_glMaterialxv(glMaterialxv_t f) { glMaterialxv_t retval = glMaterialxv; glMaterialxv = f; return retval;} + glMatrixMode_t set_glMatrixMode(glMatrixMode_t f) { glMatrixMode_t retval = glMatrixMode; glMatrixMode = f; return retval;} + glMultMatrixx_t set_glMultMatrixx(glMultMatrixx_t f) { glMultMatrixx_t retval = glMultMatrixx; glMultMatrixx = f; return retval;} + glMultiTexCoord4x_t set_glMultiTexCoord4x(glMultiTexCoord4x_t f) { glMultiTexCoord4x_t retval = glMultiTexCoord4x; glMultiTexCoord4x = f; return retval;} + glNormal3x_t set_glNormal3x(glNormal3x_t f) { glNormal3x_t retval = glNormal3x; glNormal3x = f; return retval;} + glNormalPointer_t set_glNormalPointer(glNormalPointer_t f) { glNormalPointer_t retval = glNormalPointer; glNormalPointer = f; return retval;} + glOrthox_t set_glOrthox(glOrthox_t f) { glOrthox_t retval = glOrthox; glOrthox = f; return retval;} + glPixelStorei_t set_glPixelStorei(glPixelStorei_t f) { glPixelStorei_t retval = glPixelStorei; glPixelStorei = f; return retval;} + glPointParameterx_t set_glPointParameterx(glPointParameterx_t f) { glPointParameterx_t retval = glPointParameterx; glPointParameterx = f; return retval;} + glPointParameterxv_t set_glPointParameterxv(glPointParameterxv_t f) { glPointParameterxv_t retval = glPointParameterxv; glPointParameterxv = f; return retval;} + glPointSizex_t set_glPointSizex(glPointSizex_t f) { glPointSizex_t retval = glPointSizex; glPointSizex = f; return retval;} + glPolygonOffsetx_t set_glPolygonOffsetx(glPolygonOffsetx_t f) { glPolygonOffsetx_t retval = glPolygonOffsetx; glPolygonOffsetx = f; return retval;} + glPopMatrix_t set_glPopMatrix(glPopMatrix_t f) { glPopMatrix_t retval = glPopMatrix; glPopMatrix = f; return retval;} + glPushMatrix_t set_glPushMatrix(glPushMatrix_t f) { glPushMatrix_t retval = glPushMatrix; glPushMatrix = f; return retval;} + glReadPixels_t set_glReadPixels(glReadPixels_t f) { glReadPixels_t retval = glReadPixels; glReadPixels = f; return retval;} + glRotatex_t set_glRotatex(glRotatex_t f) { glRotatex_t retval = glRotatex; glRotatex = f; return retval;} + glSampleCoverage_t set_glSampleCoverage(glSampleCoverage_t f) { glSampleCoverage_t retval = glSampleCoverage; glSampleCoverage = f; return retval;} + glSampleCoveragex_t set_glSampleCoveragex(glSampleCoveragex_t f) { glSampleCoveragex_t retval = glSampleCoveragex; glSampleCoveragex = f; return retval;} + glScalex_t set_glScalex(glScalex_t f) { glScalex_t retval = glScalex; glScalex = f; return retval;} + glScissor_t set_glScissor(glScissor_t f) { glScissor_t retval = glScissor; glScissor = f; return retval;} + glShadeModel_t set_glShadeModel(glShadeModel_t f) { glShadeModel_t retval = glShadeModel; glShadeModel = f; return retval;} + glStencilFunc_t set_glStencilFunc(glStencilFunc_t f) { glStencilFunc_t retval = glStencilFunc; glStencilFunc = f; return retval;} + glStencilMask_t set_glStencilMask(glStencilMask_t f) { glStencilMask_t retval = glStencilMask; glStencilMask = f; return retval;} + glStencilOp_t set_glStencilOp(glStencilOp_t f) { glStencilOp_t retval = glStencilOp; glStencilOp = f; return retval;} + glTexCoordPointer_t set_glTexCoordPointer(glTexCoordPointer_t f) { glTexCoordPointer_t retval = glTexCoordPointer; glTexCoordPointer = f; return retval;} + glTexEnvi_t set_glTexEnvi(glTexEnvi_t f) { glTexEnvi_t retval = glTexEnvi; glTexEnvi = f; return retval;} + glTexEnvx_t set_glTexEnvx(glTexEnvx_t f) { glTexEnvx_t retval = glTexEnvx; glTexEnvx = f; return retval;} + glTexEnviv_t set_glTexEnviv(glTexEnviv_t f) { glTexEnviv_t retval = glTexEnviv; glTexEnviv = f; return retval;} + glTexEnvxv_t set_glTexEnvxv(glTexEnvxv_t f) { glTexEnvxv_t retval = glTexEnvxv; glTexEnvxv = f; return retval;} + glTexImage2D_t set_glTexImage2D(glTexImage2D_t f) { glTexImage2D_t retval = glTexImage2D; glTexImage2D = f; return retval;} + glTexParameteri_t set_glTexParameteri(glTexParameteri_t f) { glTexParameteri_t retval = glTexParameteri; glTexParameteri = f; return retval;} + glTexParameterx_t set_glTexParameterx(glTexParameterx_t f) { glTexParameterx_t retval = glTexParameterx; glTexParameterx = f; return retval;} + glTexParameteriv_t set_glTexParameteriv(glTexParameteriv_t f) { glTexParameteriv_t retval = glTexParameteriv; glTexParameteriv = f; return retval;} + glTexParameterxv_t set_glTexParameterxv(glTexParameterxv_t f) { glTexParameterxv_t retval = glTexParameterxv; glTexParameterxv = f; return retval;} + glTexSubImage2D_t set_glTexSubImage2D(glTexSubImage2D_t f) { glTexSubImage2D_t retval = glTexSubImage2D; glTexSubImage2D = f; return retval;} + glTranslatex_t set_glTranslatex(glTranslatex_t f) { glTranslatex_t retval = glTranslatex; glTranslatex = f; return retval;} + glVertexPointer_t set_glVertexPointer(glVertexPointer_t f) { glVertexPointer_t retval = glVertexPointer; glVertexPointer = f; return retval;} + glViewport_t set_glViewport(glViewport_t f) { glViewport_t retval = glViewport; glViewport = f; return retval;} + glPointSizePointerOES_t set_glPointSizePointerOES(glPointSizePointerOES_t f) { glPointSizePointerOES_t retval = glPointSizePointerOES; glPointSizePointerOES = f; return retval;} + glBlendEquationSeparateOES_t set_glBlendEquationSeparateOES(glBlendEquationSeparateOES_t f) { glBlendEquationSeparateOES_t retval = glBlendEquationSeparateOES; glBlendEquationSeparateOES = f; return retval;} + glBlendFuncSeparateOES_t set_glBlendFuncSeparateOES(glBlendFuncSeparateOES_t f) { glBlendFuncSeparateOES_t retval = glBlendFuncSeparateOES; glBlendFuncSeparateOES = f; return retval;} + glBlendEquationOES_t set_glBlendEquationOES(glBlendEquationOES_t f) { glBlendEquationOES_t retval = glBlendEquationOES; glBlendEquationOES = f; return retval;} + glDrawTexsOES_t set_glDrawTexsOES(glDrawTexsOES_t f) { glDrawTexsOES_t retval = glDrawTexsOES; glDrawTexsOES = f; return retval;} + glDrawTexiOES_t set_glDrawTexiOES(glDrawTexiOES_t f) { glDrawTexiOES_t retval = glDrawTexiOES; glDrawTexiOES = f; return retval;} + glDrawTexxOES_t set_glDrawTexxOES(glDrawTexxOES_t f) { glDrawTexxOES_t retval = glDrawTexxOES; glDrawTexxOES = f; return retval;} + glDrawTexsvOES_t set_glDrawTexsvOES(glDrawTexsvOES_t f) { glDrawTexsvOES_t retval = glDrawTexsvOES; glDrawTexsvOES = f; return retval;} + glDrawTexivOES_t set_glDrawTexivOES(glDrawTexivOES_t f) { glDrawTexivOES_t retval = glDrawTexivOES; glDrawTexivOES = f; return retval;} + glDrawTexxvOES_t set_glDrawTexxvOES(glDrawTexxvOES_t f) { glDrawTexxvOES_t retval = glDrawTexxvOES; glDrawTexxvOES = f; return retval;} + glDrawTexfOES_t set_glDrawTexfOES(glDrawTexfOES_t f) { glDrawTexfOES_t retval = glDrawTexfOES; glDrawTexfOES = f; return retval;} + glDrawTexfvOES_t set_glDrawTexfvOES(glDrawTexfvOES_t f) { glDrawTexfvOES_t retval = glDrawTexfvOES; glDrawTexfvOES = f; return retval;} + glEGLImageTargetTexture2DOES_t set_glEGLImageTargetTexture2DOES(glEGLImageTargetTexture2DOES_t f) { glEGLImageTargetTexture2DOES_t retval = glEGLImageTargetTexture2DOES; glEGLImageTargetTexture2DOES = f; return retval;} + glEGLImageTargetRenderbufferStorageOES_t set_glEGLImageTargetRenderbufferStorageOES(glEGLImageTargetRenderbufferStorageOES_t f) { glEGLImageTargetRenderbufferStorageOES_t retval = glEGLImageTargetRenderbufferStorageOES; glEGLImageTargetRenderbufferStorageOES = f; return retval;} + glAlphaFuncxOES_t set_glAlphaFuncxOES(glAlphaFuncxOES_t f) { glAlphaFuncxOES_t retval = glAlphaFuncxOES; glAlphaFuncxOES = f; return retval;} + glClearColorxOES_t set_glClearColorxOES(glClearColorxOES_t f) { glClearColorxOES_t retval = glClearColorxOES; glClearColorxOES = f; return retval;} + glClearDepthxOES_t set_glClearDepthxOES(glClearDepthxOES_t f) { glClearDepthxOES_t retval = glClearDepthxOES; glClearDepthxOES = f; return retval;} + glClipPlanexOES_t set_glClipPlanexOES(glClipPlanexOES_t f) { glClipPlanexOES_t retval = glClipPlanexOES; glClipPlanexOES = f; return retval;} + glColor4xOES_t set_glColor4xOES(glColor4xOES_t f) { glColor4xOES_t retval = glColor4xOES; glColor4xOES = f; return retval;} + glDepthRangexOES_t set_glDepthRangexOES(glDepthRangexOES_t f) { glDepthRangexOES_t retval = glDepthRangexOES; glDepthRangexOES = f; return retval;} + glFogxOES_t set_glFogxOES(glFogxOES_t f) { glFogxOES_t retval = glFogxOES; glFogxOES = f; return retval;} + glFogxvOES_t set_glFogxvOES(glFogxvOES_t f) { glFogxvOES_t retval = glFogxvOES; glFogxvOES = f; return retval;} + glFrustumxOES_t set_glFrustumxOES(glFrustumxOES_t f) { glFrustumxOES_t retval = glFrustumxOES; glFrustumxOES = f; return retval;} + glGetClipPlanexOES_t set_glGetClipPlanexOES(glGetClipPlanexOES_t f) { glGetClipPlanexOES_t retval = glGetClipPlanexOES; glGetClipPlanexOES = f; return retval;} + glGetFixedvOES_t set_glGetFixedvOES(glGetFixedvOES_t f) { glGetFixedvOES_t retval = glGetFixedvOES; glGetFixedvOES = f; return retval;} + glGetLightxvOES_t set_glGetLightxvOES(glGetLightxvOES_t f) { glGetLightxvOES_t retval = glGetLightxvOES; glGetLightxvOES = f; return retval;} + glGetMaterialxvOES_t set_glGetMaterialxvOES(glGetMaterialxvOES_t f) { glGetMaterialxvOES_t retval = glGetMaterialxvOES; glGetMaterialxvOES = f; return retval;} + glGetTexEnvxvOES_t set_glGetTexEnvxvOES(glGetTexEnvxvOES_t f) { glGetTexEnvxvOES_t retval = glGetTexEnvxvOES; glGetTexEnvxvOES = f; return retval;} + glGetTexParameterxvOES_t set_glGetTexParameterxvOES(glGetTexParameterxvOES_t f) { glGetTexParameterxvOES_t retval = glGetTexParameterxvOES; glGetTexParameterxvOES = f; return retval;} + glLightModelxOES_t set_glLightModelxOES(glLightModelxOES_t f) { glLightModelxOES_t retval = glLightModelxOES; glLightModelxOES = f; return retval;} + glLightModelxvOES_t set_glLightModelxvOES(glLightModelxvOES_t f) { glLightModelxvOES_t retval = glLightModelxvOES; glLightModelxvOES = f; return retval;} + glLightxOES_t set_glLightxOES(glLightxOES_t f) { glLightxOES_t retval = glLightxOES; glLightxOES = f; return retval;} + glLightxvOES_t set_glLightxvOES(glLightxvOES_t f) { glLightxvOES_t retval = glLightxvOES; glLightxvOES = f; return retval;} + glLineWidthxOES_t set_glLineWidthxOES(glLineWidthxOES_t f) { glLineWidthxOES_t retval = glLineWidthxOES; glLineWidthxOES = f; return retval;} + glLoadMatrixxOES_t set_glLoadMatrixxOES(glLoadMatrixxOES_t f) { glLoadMatrixxOES_t retval = glLoadMatrixxOES; glLoadMatrixxOES = f; return retval;} + glMaterialxOES_t set_glMaterialxOES(glMaterialxOES_t f) { glMaterialxOES_t retval = glMaterialxOES; glMaterialxOES = f; return retval;} + glMaterialxvOES_t set_glMaterialxvOES(glMaterialxvOES_t f) { glMaterialxvOES_t retval = glMaterialxvOES; glMaterialxvOES = f; return retval;} + glMultMatrixxOES_t set_glMultMatrixxOES(glMultMatrixxOES_t f) { glMultMatrixxOES_t retval = glMultMatrixxOES; glMultMatrixxOES = f; return retval;} + glMultiTexCoord4xOES_t set_glMultiTexCoord4xOES(glMultiTexCoord4xOES_t f) { glMultiTexCoord4xOES_t retval = glMultiTexCoord4xOES; glMultiTexCoord4xOES = f; return retval;} + glNormal3xOES_t set_glNormal3xOES(glNormal3xOES_t f) { glNormal3xOES_t retval = glNormal3xOES; glNormal3xOES = f; return retval;} + glOrthoxOES_t set_glOrthoxOES(glOrthoxOES_t f) { glOrthoxOES_t retval = glOrthoxOES; glOrthoxOES = f; return retval;} + glPointParameterxOES_t set_glPointParameterxOES(glPointParameterxOES_t f) { glPointParameterxOES_t retval = glPointParameterxOES; glPointParameterxOES = f; return retval;} + glPointParameterxvOES_t set_glPointParameterxvOES(glPointParameterxvOES_t f) { glPointParameterxvOES_t retval = glPointParameterxvOES; glPointParameterxvOES = f; return retval;} + glPointSizexOES_t set_glPointSizexOES(glPointSizexOES_t f) { glPointSizexOES_t retval = glPointSizexOES; glPointSizexOES = f; return retval;} + glPolygonOffsetxOES_t set_glPolygonOffsetxOES(glPolygonOffsetxOES_t f) { glPolygonOffsetxOES_t retval = glPolygonOffsetxOES; glPolygonOffsetxOES = f; return retval;} + glRotatexOES_t set_glRotatexOES(glRotatexOES_t f) { glRotatexOES_t retval = glRotatexOES; glRotatexOES = f; return retval;} + glSampleCoveragexOES_t set_glSampleCoveragexOES(glSampleCoveragexOES_t f) { glSampleCoveragexOES_t retval = glSampleCoveragexOES; glSampleCoveragexOES = f; return retval;} + glScalexOES_t set_glScalexOES(glScalexOES_t f) { glScalexOES_t retval = glScalexOES; glScalexOES = f; return retval;} + glTexEnvxOES_t set_glTexEnvxOES(glTexEnvxOES_t f) { glTexEnvxOES_t retval = glTexEnvxOES; glTexEnvxOES = f; return retval;} + glTexEnvxvOES_t set_glTexEnvxvOES(glTexEnvxvOES_t f) { glTexEnvxvOES_t retval = glTexEnvxvOES; glTexEnvxvOES = f; return retval;} + glTexParameterxOES_t set_glTexParameterxOES(glTexParameterxOES_t f) { glTexParameterxOES_t retval = glTexParameterxOES; glTexParameterxOES = f; return retval;} + glTexParameterxvOES_t set_glTexParameterxvOES(glTexParameterxvOES_t f) { glTexParameterxvOES_t retval = glTexParameterxvOES; glTexParameterxvOES = f; return retval;} + glTranslatexOES_t set_glTranslatexOES(glTranslatexOES_t f) { glTranslatexOES_t retval = glTranslatexOES; glTranslatexOES = f; return retval;} + glIsRenderbufferOES_t set_glIsRenderbufferOES(glIsRenderbufferOES_t f) { glIsRenderbufferOES_t retval = glIsRenderbufferOES; glIsRenderbufferOES = f; return retval;} + glBindRenderbufferOES_t set_glBindRenderbufferOES(glBindRenderbufferOES_t f) { glBindRenderbufferOES_t retval = glBindRenderbufferOES; glBindRenderbufferOES = f; return retval;} + glDeleteRenderbuffersOES_t set_glDeleteRenderbuffersOES(glDeleteRenderbuffersOES_t f) { glDeleteRenderbuffersOES_t retval = glDeleteRenderbuffersOES; glDeleteRenderbuffersOES = f; return retval;} + glGenRenderbuffersOES_t set_glGenRenderbuffersOES(glGenRenderbuffersOES_t f) { glGenRenderbuffersOES_t retval = glGenRenderbuffersOES; glGenRenderbuffersOES = f; return retval;} + glRenderbufferStorageOES_t set_glRenderbufferStorageOES(glRenderbufferStorageOES_t f) { glRenderbufferStorageOES_t retval = glRenderbufferStorageOES; glRenderbufferStorageOES = f; return retval;} + glGetRenderbufferParameterivOES_t set_glGetRenderbufferParameterivOES(glGetRenderbufferParameterivOES_t f) { glGetRenderbufferParameterivOES_t retval = glGetRenderbufferParameterivOES; glGetRenderbufferParameterivOES = f; return retval;} + glIsFramebufferOES_t set_glIsFramebufferOES(glIsFramebufferOES_t f) { glIsFramebufferOES_t retval = glIsFramebufferOES; glIsFramebufferOES = f; return retval;} + glBindFramebufferOES_t set_glBindFramebufferOES(glBindFramebufferOES_t f) { glBindFramebufferOES_t retval = glBindFramebufferOES; glBindFramebufferOES = f; return retval;} + glDeleteFramebuffersOES_t set_glDeleteFramebuffersOES(glDeleteFramebuffersOES_t f) { glDeleteFramebuffersOES_t retval = glDeleteFramebuffersOES; glDeleteFramebuffersOES = f; return retval;} + glGenFramebuffersOES_t set_glGenFramebuffersOES(glGenFramebuffersOES_t f) { glGenFramebuffersOES_t retval = glGenFramebuffersOES; glGenFramebuffersOES = f; return retval;} + glCheckFramebufferStatusOES_t set_glCheckFramebufferStatusOES(glCheckFramebufferStatusOES_t f) { glCheckFramebufferStatusOES_t retval = glCheckFramebufferStatusOES; glCheckFramebufferStatusOES = f; return retval;} + glFramebufferRenderbufferOES_t set_glFramebufferRenderbufferOES(glFramebufferRenderbufferOES_t f) { glFramebufferRenderbufferOES_t retval = glFramebufferRenderbufferOES; glFramebufferRenderbufferOES = f; return retval;} + glFramebufferTexture2DOES_t set_glFramebufferTexture2DOES(glFramebufferTexture2DOES_t f) { glFramebufferTexture2DOES_t retval = glFramebufferTexture2DOES; glFramebufferTexture2DOES = f; return retval;} + glGetFramebufferAttachmentParameterivOES_t set_glGetFramebufferAttachmentParameterivOES(glGetFramebufferAttachmentParameterivOES_t f) { glGetFramebufferAttachmentParameterivOES_t retval = glGetFramebufferAttachmentParameterivOES; glGetFramebufferAttachmentParameterivOES = f; return retval;} + glGenerateMipmapOES_t set_glGenerateMipmapOES(glGenerateMipmapOES_t f) { glGenerateMipmapOES_t retval = glGenerateMipmapOES; glGenerateMipmapOES = f; return retval;} + glMapBufferOES_t set_glMapBufferOES(glMapBufferOES_t f) { glMapBufferOES_t retval = glMapBufferOES; glMapBufferOES = f; return retval;} + glUnmapBufferOES_t set_glUnmapBufferOES(glUnmapBufferOES_t f) { glUnmapBufferOES_t retval = glUnmapBufferOES; glUnmapBufferOES = f; return retval;} + glGetBufferPointervOES_t set_glGetBufferPointervOES(glGetBufferPointervOES_t f) { glGetBufferPointervOES_t retval = glGetBufferPointervOES; glGetBufferPointervOES = f; return retval;} + glCurrentPaletteMatrixOES_t set_glCurrentPaletteMatrixOES(glCurrentPaletteMatrixOES_t f) { glCurrentPaletteMatrixOES_t retval = glCurrentPaletteMatrixOES; glCurrentPaletteMatrixOES = f; return retval;} + glLoadPaletteFromModelViewMatrixOES_t set_glLoadPaletteFromModelViewMatrixOES(glLoadPaletteFromModelViewMatrixOES_t f) { glLoadPaletteFromModelViewMatrixOES_t retval = glLoadPaletteFromModelViewMatrixOES; glLoadPaletteFromModelViewMatrixOES = f; return retval;} + glMatrixIndexPointerOES_t set_glMatrixIndexPointerOES(glMatrixIndexPointerOES_t f) { glMatrixIndexPointerOES_t retval = glMatrixIndexPointerOES; glMatrixIndexPointerOES = f; return retval;} + glWeightPointerOES_t set_glWeightPointerOES(glWeightPointerOES_t f) { glWeightPointerOES_t retval = glWeightPointerOES; glWeightPointerOES = f; return retval;} + glQueryMatrixxOES_t set_glQueryMatrixxOES(glQueryMatrixxOES_t f) { glQueryMatrixxOES_t retval = glQueryMatrixxOES; glQueryMatrixxOES = f; return retval;} + glDepthRangefOES_t set_glDepthRangefOES(glDepthRangefOES_t f) { glDepthRangefOES_t retval = glDepthRangefOES; glDepthRangefOES = f; return retval;} + glFrustumfOES_t set_glFrustumfOES(glFrustumfOES_t f) { glFrustumfOES_t retval = glFrustumfOES; glFrustumfOES = f; return retval;} + glOrthofOES_t set_glOrthofOES(glOrthofOES_t f) { glOrthofOES_t retval = glOrthofOES; glOrthofOES = f; return retval;} + glClipPlanefOES_t set_glClipPlanefOES(glClipPlanefOES_t f) { glClipPlanefOES_t retval = glClipPlanefOES; glClipPlanefOES = f; return retval;} + glGetClipPlanefOES_t set_glGetClipPlanefOES(glGetClipPlanefOES_t f) { glGetClipPlanefOES_t retval = glGetClipPlanefOES; glGetClipPlanefOES = f; return retval;} + glClearDepthfOES_t set_glClearDepthfOES(glClearDepthfOES_t f) { glClearDepthfOES_t retval = glClearDepthfOES; glClearDepthfOES = f; return retval;} + glTexGenfOES_t set_glTexGenfOES(glTexGenfOES_t f) { glTexGenfOES_t retval = glTexGenfOES; glTexGenfOES = f; return retval;} + glTexGenfvOES_t set_glTexGenfvOES(glTexGenfvOES_t f) { glTexGenfvOES_t retval = glTexGenfvOES; glTexGenfvOES = f; return retval;} + glTexGeniOES_t set_glTexGeniOES(glTexGeniOES_t f) { glTexGeniOES_t retval = glTexGeniOES; glTexGeniOES = f; return retval;} + glTexGenivOES_t set_glTexGenivOES(glTexGenivOES_t f) { glTexGenivOES_t retval = glTexGenivOES; glTexGenivOES = f; return retval;} + glTexGenxOES_t set_glTexGenxOES(glTexGenxOES_t f) { glTexGenxOES_t retval = glTexGenxOES; glTexGenxOES = f; return retval;} + glTexGenxvOES_t set_glTexGenxvOES(glTexGenxvOES_t f) { glTexGenxvOES_t retval = glTexGenxvOES; glTexGenxvOES = f; return retval;} + glGetTexGenfvOES_t set_glGetTexGenfvOES(glGetTexGenfvOES_t f) { glGetTexGenfvOES_t retval = glGetTexGenfvOES; glGetTexGenfvOES = f; return retval;} + glGetTexGenivOES_t set_glGetTexGenivOES(glGetTexGenivOES_t f) { glGetTexGenivOES_t retval = glGetTexGenivOES; glGetTexGenivOES = f; return retval;} + glGetTexGenxvOES_t set_glGetTexGenxvOES(glGetTexGenxvOES_t f) { glGetTexGenxvOES_t retval = glGetTexGenxvOES; glGetTexGenxvOES = f; return retval;} + glBindVertexArrayOES_t set_glBindVertexArrayOES(glBindVertexArrayOES_t f) { glBindVertexArrayOES_t retval = glBindVertexArrayOES; glBindVertexArrayOES = f; return retval;} + glDeleteVertexArraysOES_t set_glDeleteVertexArraysOES(glDeleteVertexArraysOES_t f) { glDeleteVertexArraysOES_t retval = glDeleteVertexArraysOES; glDeleteVertexArraysOES = f; return retval;} + glGenVertexArraysOES_t set_glGenVertexArraysOES(glGenVertexArraysOES_t f) { glGenVertexArraysOES_t retval = glGenVertexArraysOES; glGenVertexArraysOES = f; return retval;} + glIsVertexArrayOES_t set_glIsVertexArrayOES(glIsVertexArrayOES_t f) { glIsVertexArrayOES_t retval = glIsVertexArrayOES; glIsVertexArrayOES = f; return retval;} + glDiscardFramebufferEXT_t set_glDiscardFramebufferEXT(glDiscardFramebufferEXT_t f) { glDiscardFramebufferEXT_t retval = glDiscardFramebufferEXT; glDiscardFramebufferEXT = f; return retval;} + glMultiDrawArraysEXT_t set_glMultiDrawArraysEXT(glMultiDrawArraysEXT_t f) { glMultiDrawArraysEXT_t retval = glMultiDrawArraysEXT; glMultiDrawArraysEXT = f; return retval;} + glMultiDrawElementsEXT_t set_glMultiDrawElementsEXT(glMultiDrawElementsEXT_t f) { glMultiDrawElementsEXT_t retval = glMultiDrawElementsEXT; glMultiDrawElementsEXT = f; return retval;} + glClipPlanefIMG_t set_glClipPlanefIMG(glClipPlanefIMG_t f) { glClipPlanefIMG_t retval = glClipPlanefIMG; glClipPlanefIMG = f; return retval;} + glClipPlanexIMG_t set_glClipPlanexIMG(glClipPlanexIMG_t f) { glClipPlanexIMG_t retval = glClipPlanexIMG; glClipPlanexIMG = f; return retval;} + glRenderbufferStorageMultisampleIMG_t set_glRenderbufferStorageMultisampleIMG(glRenderbufferStorageMultisampleIMG_t f) { glRenderbufferStorageMultisampleIMG_t retval = glRenderbufferStorageMultisampleIMG; glRenderbufferStorageMultisampleIMG = f; return retval;} + glFramebufferTexture2DMultisampleIMG_t set_glFramebufferTexture2DMultisampleIMG(glFramebufferTexture2DMultisampleIMG_t f) { glFramebufferTexture2DMultisampleIMG_t retval = glFramebufferTexture2DMultisampleIMG; glFramebufferTexture2DMultisampleIMG = f; return retval;} + glDeleteFencesNV_t set_glDeleteFencesNV(glDeleteFencesNV_t f) { glDeleteFencesNV_t retval = glDeleteFencesNV; glDeleteFencesNV = f; return retval;} + glGenFencesNV_t set_glGenFencesNV(glGenFencesNV_t f) { glGenFencesNV_t retval = glGenFencesNV; glGenFencesNV = f; return retval;} + glIsFenceNV_t set_glIsFenceNV(glIsFenceNV_t f) { glIsFenceNV_t retval = glIsFenceNV; glIsFenceNV = f; return retval;} + glTestFenceNV_t set_glTestFenceNV(glTestFenceNV_t f) { glTestFenceNV_t retval = glTestFenceNV; glTestFenceNV = f; return retval;} + glGetFenceivNV_t set_glGetFenceivNV(glGetFenceivNV_t f) { glGetFenceivNV_t retval = glGetFenceivNV; glGetFenceivNV = f; return retval;} + glFinishFenceNV_t set_glFinishFenceNV(glFinishFenceNV_t f) { glFinishFenceNV_t retval = glFinishFenceNV; glFinishFenceNV = f; return retval;} + glSetFenceNV_t set_glSetFenceNV(glSetFenceNV_t f) { glSetFenceNV_t retval = glSetFenceNV; glSetFenceNV = f; return retval;} + glGetDriverControlsQCOM_t set_glGetDriverControlsQCOM(glGetDriverControlsQCOM_t f) { glGetDriverControlsQCOM_t retval = glGetDriverControlsQCOM; glGetDriverControlsQCOM = f; return retval;} + glGetDriverControlStringQCOM_t set_glGetDriverControlStringQCOM(glGetDriverControlStringQCOM_t f) { glGetDriverControlStringQCOM_t retval = glGetDriverControlStringQCOM; glGetDriverControlStringQCOM = f; return retval;} + glEnableDriverControlQCOM_t set_glEnableDriverControlQCOM(glEnableDriverControlQCOM_t f) { glEnableDriverControlQCOM_t retval = glEnableDriverControlQCOM; glEnableDriverControlQCOM = f; return retval;} + glDisableDriverControlQCOM_t set_glDisableDriverControlQCOM(glDisableDriverControlQCOM_t f) { glDisableDriverControlQCOM_t retval = glDisableDriverControlQCOM; glDisableDriverControlQCOM = f; return retval;} + glExtGetTexturesQCOM_t set_glExtGetTexturesQCOM(glExtGetTexturesQCOM_t f) { glExtGetTexturesQCOM_t retval = glExtGetTexturesQCOM; glExtGetTexturesQCOM = f; return retval;} + glExtGetBuffersQCOM_t set_glExtGetBuffersQCOM(glExtGetBuffersQCOM_t f) { glExtGetBuffersQCOM_t retval = glExtGetBuffersQCOM; glExtGetBuffersQCOM = f; return retval;} + glExtGetRenderbuffersQCOM_t set_glExtGetRenderbuffersQCOM(glExtGetRenderbuffersQCOM_t f) { glExtGetRenderbuffersQCOM_t retval = glExtGetRenderbuffersQCOM; glExtGetRenderbuffersQCOM = f; return retval;} + glExtGetFramebuffersQCOM_t set_glExtGetFramebuffersQCOM(glExtGetFramebuffersQCOM_t f) { glExtGetFramebuffersQCOM_t retval = glExtGetFramebuffersQCOM; glExtGetFramebuffersQCOM = f; return retval;} + glExtGetTexLevelParameterivQCOM_t set_glExtGetTexLevelParameterivQCOM(glExtGetTexLevelParameterivQCOM_t f) { glExtGetTexLevelParameterivQCOM_t retval = glExtGetTexLevelParameterivQCOM; glExtGetTexLevelParameterivQCOM = f; return retval;} + glExtTexObjectStateOverrideiQCOM_t set_glExtTexObjectStateOverrideiQCOM(glExtTexObjectStateOverrideiQCOM_t f) { glExtTexObjectStateOverrideiQCOM_t retval = glExtTexObjectStateOverrideiQCOM; glExtTexObjectStateOverrideiQCOM = f; return retval;} + glExtGetTexSubImageQCOM_t set_glExtGetTexSubImageQCOM(glExtGetTexSubImageQCOM_t f) { glExtGetTexSubImageQCOM_t retval = glExtGetTexSubImageQCOM; glExtGetTexSubImageQCOM = f; return retval;} + glExtGetBufferPointervQCOM_t set_glExtGetBufferPointervQCOM(glExtGetBufferPointervQCOM_t f) { glExtGetBufferPointervQCOM_t retval = glExtGetBufferPointervQCOM; glExtGetBufferPointervQCOM = f; return retval;} + glExtGetShadersQCOM_t set_glExtGetShadersQCOM(glExtGetShadersQCOM_t f) { glExtGetShadersQCOM_t retval = glExtGetShadersQCOM; glExtGetShadersQCOM = f; return retval;} + glExtGetProgramsQCOM_t set_glExtGetProgramsQCOM(glExtGetProgramsQCOM_t f) { glExtGetProgramsQCOM_t retval = glExtGetProgramsQCOM; glExtGetProgramsQCOM = f; return retval;} + glExtIsProgramBinaryQCOM_t set_glExtIsProgramBinaryQCOM(glExtIsProgramBinaryQCOM_t f) { glExtIsProgramBinaryQCOM_t retval = glExtIsProgramBinaryQCOM; glExtIsProgramBinaryQCOM = f; return retval;} + glExtGetProgramBinarySourceQCOM_t set_glExtGetProgramBinarySourceQCOM(glExtGetProgramBinarySourceQCOM_t f) { glExtGetProgramBinarySourceQCOM_t retval = glExtGetProgramBinarySourceQCOM; glExtGetProgramBinarySourceQCOM = f; return retval;} + glStartTilingQCOM_t set_glStartTilingQCOM(glStartTilingQCOM_t f) { glStartTilingQCOM_t retval = glStartTilingQCOM; glStartTilingQCOM = f; return retval;} + glEndTilingQCOM_t set_glEndTilingQCOM(glEndTilingQCOM_t f) { glEndTilingQCOM_t retval = glEndTilingQCOM; glEndTilingQCOM = f; return retval;} +}; + +gles_dispatch *create_gles_dispatch(void *gles_andorid); + +#endif diff --git a/emulator/opengl/tests/gles_android_wrapper/gles_emul.cfg b/emulator/opengl/tests/gles_android_wrapper/gles_emul.cfg new file mode 100644 index 0000000..a837807 --- /dev/null +++ b/emulator/opengl/tests/gles_android_wrapper/gles_emul.cfg @@ -0,0 +1,7 @@ +angeles +my-tritex +org.zeroxlab.benchmark +com.cooliris.media +com.polarbit.waveblazerlite +test-opengl-gl2_basic +com.trendy.ddapp diff --git a/emulator/opengl/tests/gles_android_wrapper/gles_ftable.h b/emulator/opengl/tests/gles_android_wrapper/gles_ftable.h new file mode 100644 index 0000000..1895b18 --- /dev/null +++ b/emulator/opengl/tests/gles_android_wrapper/gles_ftable.h @@ -0,0 +1,292 @@ +/* +* Copyright (C) 2011 The Android Open Source Project +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ +static struct _gles_funcs_by_name { + const char *name; + void *proc; +} gles_funcs_by_name[] = { + {"glAlphaFunc", (void *)glAlphaFunc}, + {"glClearColor", (void *)glClearColor}, + {"glClearDepthf", (void *)glClearDepthf}, + {"glClipPlanef", (void *)glClipPlanef}, + {"glColor4f", (void *)glColor4f}, + {"glDepthRangef", (void *)glDepthRangef}, + {"glFogf", (void *)glFogf}, + {"glFogfv", (void *)glFogfv}, + {"glFrustumf", (void *)glFrustumf}, + {"glGetClipPlanef", (void *)glGetClipPlanef}, + {"glGetFloatv", (void *)glGetFloatv}, + {"glGetLightfv", (void *)glGetLightfv}, + {"glGetMaterialfv", (void *)glGetMaterialfv}, + {"glGetTexEnvfv", (void *)glGetTexEnvfv}, + {"glGetTexParameterfv", (void *)glGetTexParameterfv}, + {"glLightModelf", (void *)glLightModelf}, + {"glLightModelfv", (void *)glLightModelfv}, + {"glLightf", (void *)glLightf}, + {"glLightfv", (void *)glLightfv}, + {"glLineWidth", (void *)glLineWidth}, + {"glLoadMatrixf", (void *)glLoadMatrixf}, + {"glMaterialf", (void *)glMaterialf}, + {"glMaterialfv", (void *)glMaterialfv}, + {"glMultMatrixf", (void *)glMultMatrixf}, + {"glMultiTexCoord4f", (void *)glMultiTexCoord4f}, + {"glNormal3f", (void *)glNormal3f}, + {"glOrthof", (void *)glOrthof}, + {"glPointParameterf", (void *)glPointParameterf}, + {"glPointParameterfv", (void *)glPointParameterfv}, + {"glPointSize", (void *)glPointSize}, + {"glPolygonOffset", (void *)glPolygonOffset}, + {"glRotatef", (void *)glRotatef}, + {"glScalef", (void *)glScalef}, + {"glTexEnvf", (void *)glTexEnvf}, + {"glTexEnvfv", (void *)glTexEnvfv}, + {"glTexParameterf", (void *)glTexParameterf}, + {"glTexParameterfv", (void *)glTexParameterfv}, + {"glTranslatef", (void *)glTranslatef}, + {"glActiveTexture", (void *)glActiveTexture}, + {"glAlphaFuncx", (void *)glAlphaFuncx}, + {"glBindBuffer", (void *)glBindBuffer}, + {"glBindTexture", (void *)glBindTexture}, + {"glBlendFunc", (void *)glBlendFunc}, + {"glBufferData", (void *)glBufferData}, + {"glBufferSubData", (void *)glBufferSubData}, + {"glClear", (void *)glClear}, + {"glClearColorx", (void *)glClearColorx}, + {"glClearDepthx", (void *)glClearDepthx}, + {"glClearStencil", (void *)glClearStencil}, + {"glClientActiveTexture", (void *)glClientActiveTexture}, + {"glClipPlanex", (void *)glClipPlanex}, + {"glColor4ub", (void *)glColor4ub}, + {"glColor4x", (void *)glColor4x}, + {"glColorMask", (void *)glColorMask}, + {"glColorPointer", (void *)glColorPointer}, + {"glCompressedTexImage2D", (void *)glCompressedTexImage2D}, + {"glCompressedTexSubImage2D", (void *)glCompressedTexSubImage2D}, + {"glCopyTexImage2D", (void *)glCopyTexImage2D}, + {"glCopyTexSubImage2D", (void *)glCopyTexSubImage2D}, + {"glCullFace", (void *)glCullFace}, + {"glDeleteBuffers", (void *)glDeleteBuffers}, + {"glDeleteTextures", (void *)glDeleteTextures}, + {"glDepthFunc", (void *)glDepthFunc}, + {"glDepthMask", (void *)glDepthMask}, + {"glDepthRangex", (void *)glDepthRangex}, + {"glDisable", (void *)glDisable}, + {"glDisableClientState", (void *)glDisableClientState}, + {"glDrawArrays", (void *)glDrawArrays}, + {"glDrawElements", (void *)glDrawElements}, + {"glEnable", (void *)glEnable}, + {"glEnableClientState", (void *)glEnableClientState}, + {"glFinish", (void *)glFinish}, + {"glFlush", (void *)glFlush}, + {"glFogx", (void *)glFogx}, + {"glFogxv", (void *)glFogxv}, + {"glFrontFace", (void *)glFrontFace}, + {"glFrustumx", (void *)glFrustumx}, + {"glGetBooleanv", (void *)glGetBooleanv}, + {"glGetBufferParameteriv", (void *)glGetBufferParameteriv}, + {"glGetClipPlanex", (void *)glGetClipPlanex}, + {"glGenBuffers", (void *)glGenBuffers}, + {"glGenTextures", (void *)glGenTextures}, + {"glGetError", (void *)glGetError}, + {"glGetFixedv", (void *)glGetFixedv}, + {"glGetIntegerv", (void *)glGetIntegerv}, + {"glGetLightxv", (void *)glGetLightxv}, + {"glGetMaterialxv", (void *)glGetMaterialxv}, + {"glGetPointerv", (void *)glGetPointerv}, + {"glGetString", (void *)glGetString}, + {"glGetTexEnviv", (void *)glGetTexEnviv}, + {"glGetTexEnvxv", (void *)glGetTexEnvxv}, + {"glGetTexParameteriv", (void *)glGetTexParameteriv}, + {"glGetTexParameterxv", (void *)glGetTexParameterxv}, + {"glHint", (void *)glHint}, + {"glIsBuffer", (void *)glIsBuffer}, + {"glIsEnabled", (void *)glIsEnabled}, + {"glIsTexture", (void *)glIsTexture}, + {"glLightModelx", (void *)glLightModelx}, + {"glLightModelxv", (void *)glLightModelxv}, + {"glLightx", (void *)glLightx}, + {"glLightxv", (void *)glLightxv}, + {"glLineWidthx", (void *)glLineWidthx}, + {"glLoadIdentity", (void *)glLoadIdentity}, + {"glLoadMatrixx", (void *)glLoadMatrixx}, + {"glLogicOp", (void *)glLogicOp}, + {"glMaterialx", (void *)glMaterialx}, + {"glMaterialxv", (void *)glMaterialxv}, + {"glMatrixMode", (void *)glMatrixMode}, + {"glMultMatrixx", (void *)glMultMatrixx}, + {"glMultiTexCoord4x", (void *)glMultiTexCoord4x}, + {"glNormal3x", (void *)glNormal3x}, + {"glNormalPointer", (void *)glNormalPointer}, + {"glOrthox", (void *)glOrthox}, + {"glPixelStorei", (void *)glPixelStorei}, + {"glPointParameterx", (void *)glPointParameterx}, + {"glPointParameterxv", (void *)glPointParameterxv}, + {"glPointSizex", (void *)glPointSizex}, + {"glPolygonOffsetx", (void *)glPolygonOffsetx}, + {"glPopMatrix", (void *)glPopMatrix}, + {"glPushMatrix", (void *)glPushMatrix}, + {"glReadPixels", (void *)glReadPixels}, + {"glRotatex", (void *)glRotatex}, + {"glSampleCoverage", (void *)glSampleCoverage}, + {"glSampleCoveragex", (void *)glSampleCoveragex}, + {"glScalex", (void *)glScalex}, + {"glScissor", (void *)glScissor}, + {"glShadeModel", (void *)glShadeModel}, + {"glStencilFunc", (void *)glStencilFunc}, + {"glStencilMask", (void *)glStencilMask}, + {"glStencilOp", (void *)glStencilOp}, + {"glTexCoordPointer", (void *)glTexCoordPointer}, + {"glTexEnvi", (void *)glTexEnvi}, + {"glTexEnvx", (void *)glTexEnvx}, + {"glTexEnviv", (void *)glTexEnviv}, + {"glTexEnvxv", (void *)glTexEnvxv}, + {"glTexImage2D", (void *)glTexImage2D}, + {"glTexParameteri", (void *)glTexParameteri}, + {"glTexParameterx", (void *)glTexParameterx}, + {"glTexParameteriv", (void *)glTexParameteriv}, + {"glTexParameterxv", (void *)glTexParameterxv}, + {"glTexSubImage2D", (void *)glTexSubImage2D}, + {"glTranslatex", (void *)glTranslatex}, + {"glVertexPointer", (void *)glVertexPointer}, + {"glViewport", (void *)glViewport}, + {"glPointSizePointerOES", (void *)glPointSizePointerOES}, + {"glBlendEquationSeparateOES", (void *)glBlendEquationSeparateOES}, + {"glBlendFuncSeparateOES", (void *)glBlendFuncSeparateOES}, + {"glBlendEquationOES", (void *)glBlendEquationOES}, + {"glDrawTexsOES", (void *)glDrawTexsOES}, + {"glDrawTexiOES", (void *)glDrawTexiOES}, + {"glDrawTexxOES", (void *)glDrawTexxOES}, + {"glDrawTexsvOES", (void *)glDrawTexsvOES}, + {"glDrawTexivOES", (void *)glDrawTexivOES}, + {"glDrawTexxvOES", (void *)glDrawTexxvOES}, + {"glDrawTexfOES", (void *)glDrawTexfOES}, + {"glDrawTexfvOES", (void *)glDrawTexfvOES}, + {"glEGLImageTargetTexture2DOES", (void *)glEGLImageTargetTexture2DOES}, + {"glEGLImageTargetRenderbufferStorageOES", (void *)glEGLImageTargetRenderbufferStorageOES}, + {"glAlphaFuncxOES", (void *)glAlphaFuncxOES}, + {"glClearColorxOES", (void *)glClearColorxOES}, + {"glClearDepthxOES", (void *)glClearDepthxOES}, + {"glClipPlanexOES", (void *)glClipPlanexOES}, + {"glColor4xOES", (void *)glColor4xOES}, + {"glDepthRangexOES", (void *)glDepthRangexOES}, + {"glFogxOES", (void *)glFogxOES}, + {"glFogxvOES", (void *)glFogxvOES}, + {"glFrustumxOES", (void *)glFrustumxOES}, + {"glGetClipPlanexOES", (void *)glGetClipPlanexOES}, + {"glGetFixedvOES", (void *)glGetFixedvOES}, + {"glGetLightxvOES", (void *)glGetLightxvOES}, + {"glGetMaterialxvOES", (void *)glGetMaterialxvOES}, + {"glGetTexEnvxvOES", (void *)glGetTexEnvxvOES}, + {"glGetTexParameterxvOES", (void *)glGetTexParameterxvOES}, + {"glLightModelxOES", (void *)glLightModelxOES}, + {"glLightModelxvOES", (void *)glLightModelxvOES}, + {"glLightxOES", (void *)glLightxOES}, + {"glLightxvOES", (void *)glLightxvOES}, + {"glLineWidthxOES", (void *)glLineWidthxOES}, + {"glLoadMatrixxOES", (void *)glLoadMatrixxOES}, + {"glMaterialxOES", (void *)glMaterialxOES}, + {"glMaterialxvOES", (void *)glMaterialxvOES}, + {"glMultMatrixxOES", (void *)glMultMatrixxOES}, + {"glMultiTexCoord4xOES", (void *)glMultiTexCoord4xOES}, + {"glNormal3xOES", (void *)glNormal3xOES}, + {"glOrthoxOES", (void *)glOrthoxOES}, + {"glPointParameterxOES", (void *)glPointParameterxOES}, + {"glPointParameterxvOES", (void *)glPointParameterxvOES}, + {"glPointSizexOES", (void *)glPointSizexOES}, + {"glPolygonOffsetxOES", (void *)glPolygonOffsetxOES}, + {"glRotatexOES", (void *)glRotatexOES}, + {"glSampleCoveragexOES", (void *)glSampleCoveragexOES}, + {"glScalexOES", (void *)glScalexOES}, + {"glTexEnvxOES", (void *)glTexEnvxOES}, + {"glTexEnvxvOES", (void *)glTexEnvxvOES}, + {"glTexParameterxOES", (void *)glTexParameterxOES}, + {"glTexParameterxvOES", (void *)glTexParameterxvOES}, + {"glTranslatexOES", (void *)glTranslatexOES}, + {"glIsRenderbufferOES", (void *)glIsRenderbufferOES}, + {"glBindRenderbufferOES", (void *)glBindRenderbufferOES}, + {"glDeleteRenderbuffersOES", (void *)glDeleteRenderbuffersOES}, + {"glGenRenderbuffersOES", (void *)glGenRenderbuffersOES}, + {"glRenderbufferStorageOES", (void *)glRenderbufferStorageOES}, + {"glGetRenderbufferParameterivOES", (void *)glGetRenderbufferParameterivOES}, + {"glIsFramebufferOES", (void *)glIsFramebufferOES}, + {"glBindFramebufferOES", (void *)glBindFramebufferOES}, + {"glDeleteFramebuffersOES", (void *)glDeleteFramebuffersOES}, + {"glGenFramebuffersOES", (void *)glGenFramebuffersOES}, + {"glCheckFramebufferStatusOES", (void *)glCheckFramebufferStatusOES}, + {"glFramebufferRenderbufferOES", (void *)glFramebufferRenderbufferOES}, + {"glFramebufferTexture2DOES", (void *)glFramebufferTexture2DOES}, + {"glGetFramebufferAttachmentParameterivOES", (void *)glGetFramebufferAttachmentParameterivOES}, + {"glGenerateMipmapOES", (void *)glGenerateMipmapOES}, + {"glMapBufferOES", (void *)glMapBufferOES}, + {"glUnmapBufferOES", (void *)glUnmapBufferOES}, + {"glGetBufferPointervOES", (void *)glGetBufferPointervOES}, + {"glCurrentPaletteMatrixOES", (void *)glCurrentPaletteMatrixOES}, + {"glLoadPaletteFromModelViewMatrixOES", (void *)glLoadPaletteFromModelViewMatrixOES}, + {"glMatrixIndexPointerOES", (void *)glMatrixIndexPointerOES}, + {"glWeightPointerOES", (void *)glWeightPointerOES}, + {"glQueryMatrixxOES", (void *)glQueryMatrixxOES}, + {"glDepthRangefOES", (void *)glDepthRangefOES}, + {"glFrustumfOES", (void *)glFrustumfOES}, + {"glOrthofOES", (void *)glOrthofOES}, + {"glClipPlanefOES", (void *)glClipPlanefOES}, + {"glGetClipPlanefOES", (void *)glGetClipPlanefOES}, + {"glClearDepthfOES", (void *)glClearDepthfOES}, + {"glTexGenfOES", (void *)glTexGenfOES}, + {"glTexGenfvOES", (void *)glTexGenfvOES}, + {"glTexGeniOES", (void *)glTexGeniOES}, + {"glTexGenivOES", (void *)glTexGenivOES}, + {"glTexGenxOES", (void *)glTexGenxOES}, + {"glTexGenxvOES", (void *)glTexGenxvOES}, + {"glGetTexGenfvOES", (void *)glGetTexGenfvOES}, + {"glGetTexGenivOES", (void *)glGetTexGenivOES}, + {"glGetTexGenxvOES", (void *)glGetTexGenxvOES}, + {"glBindVertexArrayOES", (void *)glBindVertexArrayOES}, + {"glDeleteVertexArraysOES", (void *)glDeleteVertexArraysOES}, + {"glGenVertexArraysOES", (void *)glGenVertexArraysOES}, + {"glIsVertexArrayOES", (void *)glIsVertexArrayOES}, + {"glDiscardFramebufferEXT", (void *)glDiscardFramebufferEXT}, + {"glMultiDrawArraysEXT", (void *)glMultiDrawArraysEXT}, + {"glMultiDrawElementsEXT", (void *)glMultiDrawElementsEXT}, + {"glClipPlanefIMG", (void *)glClipPlanefIMG}, + {"glClipPlanexIMG", (void *)glClipPlanexIMG}, + {"glRenderbufferStorageMultisampleIMG", (void *)glRenderbufferStorageMultisampleIMG}, + {"glFramebufferTexture2DMultisampleIMG", (void *)glFramebufferTexture2DMultisampleIMG}, + {"glDeleteFencesNV", (void *)glDeleteFencesNV}, + {"glGenFencesNV", (void *)glGenFencesNV}, + {"glIsFenceNV", (void *)glIsFenceNV}, + {"glTestFenceNV", (void *)glTestFenceNV}, + {"glGetFenceivNV", (void *)glGetFenceivNV}, + {"glFinishFenceNV", (void *)glFinishFenceNV}, + {"glSetFenceNV", (void *)glSetFenceNV}, + {"glGetDriverControlsQCOM", (void *)glGetDriverControlsQCOM}, + {"glGetDriverControlStringQCOM", (void *)glGetDriverControlStringQCOM}, + {"glEnableDriverControlQCOM", (void *)glEnableDriverControlQCOM}, + {"glDisableDriverControlQCOM", (void *)glDisableDriverControlQCOM}, + {"glExtGetTexturesQCOM", (void *)glExtGetTexturesQCOM}, + {"glExtGetBuffersQCOM", (void *)glExtGetBuffersQCOM}, + {"glExtGetRenderbuffersQCOM", (void *)glExtGetRenderbuffersQCOM}, + {"glExtGetFramebuffersQCOM", (void *)glExtGetFramebuffersQCOM}, + {"glExtGetTexLevelParameterivQCOM", (void *)glExtGetTexLevelParameterivQCOM}, + {"glExtTexObjectStateOverrideiQCOM", (void *)glExtTexObjectStateOverrideiQCOM}, + {"glExtGetTexSubImageQCOM", (void *)glExtGetTexSubImageQCOM}, + {"glExtGetBufferPointervQCOM", (void *)glExtGetBufferPointervQCOM}, + {"glExtGetShadersQCOM", (void *)glExtGetShadersQCOM}, + {"glExtGetProgramsQCOM", (void *)glExtGetProgramsQCOM}, + {"glExtIsProgramBinaryQCOM", (void *)glExtIsProgramBinaryQCOM}, + {"glExtGetProgramBinarySourceQCOM", (void *)glExtGetProgramBinarySourceQCOM}, + {"glStartTilingQCOM", (void *)glStartTilingQCOM}, + {"glEndTilingQCOM", (void *)glEndTilingQCOM} +}; +static int gles_num_funcs = sizeof(gles_funcs_by_name) / sizeof(struct _gles_funcs_by_name); diff --git a/emulator/opengl/tests/gles_android_wrapper/gles_proc.h b/emulator/opengl/tests/gles_android_wrapper/gles_proc.h new file mode 100644 index 0000000..afd94b9 --- /dev/null +++ b/emulator/opengl/tests/gles_android_wrapper/gles_proc.h @@ -0,0 +1,296 @@ +/* +* Copyright (C) 2011 The Android Open Source Project +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ +#ifndef _GLES_PROC_H +#define _GLES_PROC_H + +#include <GLES/gl.h> +#define GL_GLEXT_PROTOTYPES +#include <GLES/glext.h> + +typedef void (* glAlphaFunc_t) (GLenum, GLclampf); +typedef void (* glClearColor_t) (GLclampf, GLclampf, GLclampf, GLclampf); +typedef void (* glClearDepthf_t) (GLclampf); +typedef void (* glClipPlanef_t) (GLenum, const GLfloat*); +typedef void (* glColor4f_t) (GLfloat, GLfloat, GLfloat, GLfloat); +typedef void (* glDepthRangef_t) (GLclampf, GLclampf); +typedef void (* glFogf_t) (GLenum, GLfloat); +typedef void (* glFogfv_t) (GLenum, const GLfloat*); +typedef void (* glFrustumf_t) (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); +typedef void (* glGetClipPlanef_t) (GLenum, GLfloat*); +typedef void (* glGetFloatv_t) (GLenum, GLfloat*); +typedef void (* glGetLightfv_t) (GLenum, GLenum, GLfloat*); +typedef void (* glGetMaterialfv_t) (GLenum, GLenum, GLfloat*); +typedef void (* glGetTexEnvfv_t) (GLenum, GLenum, GLfloat*); +typedef void (* glGetTexParameterfv_t) (GLenum, GLenum, GLfloat*); +typedef void (* glLightModelf_t) (GLenum, GLfloat); +typedef void (* glLightModelfv_t) (GLenum, const GLfloat*); +typedef void (* glLightf_t) (GLenum, GLenum, GLfloat); +typedef void (* glLightfv_t) (GLenum, GLenum, const GLfloat*); +typedef void (* glLineWidth_t) (GLfloat); +typedef void (* glLoadMatrixf_t) (const GLfloat*); +typedef void (* glMaterialf_t) (GLenum, GLenum, GLfloat); +typedef void (* glMaterialfv_t) (GLenum, GLenum, const GLfloat*); +typedef void (* glMultMatrixf_t) (const GLfloat*); +typedef void (* glMultiTexCoord4f_t) (GLenum, GLfloat, GLfloat, GLfloat, GLfloat); +typedef void (* glNormal3f_t) (GLfloat, GLfloat, GLfloat); +typedef void (* glOrthof_t) (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); +typedef void (* glPointParameterf_t) (GLenum, GLfloat); +typedef void (* glPointParameterfv_t) (GLenum, const GLfloat*); +typedef void (* glPointSize_t) (GLfloat); +typedef void (* glPolygonOffset_t) (GLfloat, GLfloat); +typedef void (* glRotatef_t) (GLfloat, GLfloat, GLfloat, GLfloat); +typedef void (* glScalef_t) (GLfloat, GLfloat, GLfloat); +typedef void (* glTexEnvf_t) (GLenum, GLenum, GLfloat); +typedef void (* glTexEnvfv_t) (GLenum, GLenum, const GLfloat*); +typedef void (* glTexParameterf_t) (GLenum, GLenum, GLfloat); +typedef void (* glTexParameterfv_t) (GLenum, GLenum, const GLfloat*); +typedef void (* glTranslatef_t) (GLfloat, GLfloat, GLfloat); +typedef void (* glActiveTexture_t) (GLenum); +typedef void (* glAlphaFuncx_t) (GLenum, GLclampx); +typedef void (* glBindBuffer_t) (GLenum, GLuint); +typedef void (* glBindTexture_t) (GLenum, GLuint); +typedef void (* glBlendFunc_t) (GLenum, GLenum); +typedef void (* glBufferData_t) (GLenum, GLsizeiptr, const GLvoid*, GLenum); +typedef void (* glBufferSubData_t) (GLenum, GLintptr, GLsizeiptr, const GLvoid*); +typedef void (* glClear_t) (GLbitfield); +typedef void (* glClearColorx_t) (GLclampx, GLclampx, GLclampx, GLclampx); +typedef void (* glClearDepthx_t) (GLclampx); +typedef void (* glClearStencil_t) (GLint); +typedef void (* glClientActiveTexture_t) (GLenum); +typedef void (* glClipPlanex_t) (GLenum, const GLfixed*); +typedef void (* glColor4ub_t) (GLubyte, GLubyte, GLubyte, GLubyte); +typedef void (* glColor4x_t) (GLfixed, GLfixed, GLfixed, GLfixed); +typedef void (* glColorMask_t) (GLboolean, GLboolean, GLboolean, GLboolean); +typedef void (* glColorPointer_t) (GLint, GLenum, GLsizei, const GLvoid*); +typedef void (* glCompressedTexImage2D_t) (GLenum, GLint, GLenum, GLsizei, GLsizei, GLint, GLsizei, const GLvoid*); +typedef void (* glCompressedTexSubImage2D_t) (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLsizei, const GLvoid*); +typedef void (* glCopyTexImage2D_t) (GLenum, GLint, GLenum, GLint, GLint, GLsizei, GLsizei, GLint); +typedef void (* glCopyTexSubImage2D_t) (GLenum, GLint, GLint, GLint, GLint, GLint, GLsizei, GLsizei); +typedef void (* glCullFace_t) (GLenum); +typedef void (* glDeleteBuffers_t) (GLsizei, const GLuint*); +typedef void (* glDeleteTextures_t) (GLsizei, const GLuint*); +typedef void (* glDepthFunc_t) (GLenum); +typedef void (* glDepthMask_t) (GLboolean); +typedef void (* glDepthRangex_t) (GLclampx, GLclampx); +typedef void (* glDisable_t) (GLenum); +typedef void (* glDisableClientState_t) (GLenum); +typedef void (* glDrawArrays_t) (GLenum, GLint, GLsizei); +typedef void (* glDrawElements_t) (GLenum, GLsizei, GLenum, const GLvoid*); +typedef void (* glEnable_t) (GLenum); +typedef void (* glEnableClientState_t) (GLenum); +typedef void (* glFinish_t) (); +typedef void (* glFlush_t) (); +typedef void (* glFogx_t) (GLenum, GLfixed); +typedef void (* glFogxv_t) (GLenum, const GLfixed*); +typedef void (* glFrontFace_t) (GLenum); +typedef void (* glFrustumx_t) (GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed); +typedef void (* glGetBooleanv_t) (GLenum, GLboolean*); +typedef void (* glGetBufferParameteriv_t) (GLenum, GLenum, GLint*); +typedef void (* glGetClipPlanex_t) (GLenum, GLfixed*); +typedef void (* glGenBuffers_t) (GLsizei, GLuint*); +typedef void (* glGenTextures_t) (GLsizei, GLuint*); +typedef GLenum (* glGetError_t) (); +typedef void (* glGetFixedv_t) (GLenum, GLfixed*); +typedef void (* glGetIntegerv_t) (GLenum, GLint*); +typedef void (* glGetLightxv_t) (GLenum, GLenum, GLfixed*); +typedef void (* glGetMaterialxv_t) (GLenum, GLenum, GLfixed*); +typedef void (* glGetPointerv_t) (GLenum, GLvoid**); +typedef const GLubyte* (* glGetString_t) (GLenum); +typedef void (* glGetTexEnviv_t) (GLenum, GLenum, GLint*); +typedef void (* glGetTexEnvxv_t) (GLenum, GLenum, GLfixed*); +typedef void (* glGetTexParameteriv_t) (GLenum, GLenum, GLint*); +typedef void (* glGetTexParameterxv_t) (GLenum, GLenum, GLfixed*); +typedef void (* glHint_t) (GLenum, GLenum); +typedef GLboolean (* glIsBuffer_t) (GLuint); +typedef GLboolean (* glIsEnabled_t) (GLenum); +typedef GLboolean (* glIsTexture_t) (GLuint); +typedef void (* glLightModelx_t) (GLenum, GLfixed); +typedef void (* glLightModelxv_t) (GLenum, const GLfixed*); +typedef void (* glLightx_t) (GLenum, GLenum, GLfixed); +typedef void (* glLightxv_t) (GLenum, GLenum, const GLfixed*); +typedef void (* glLineWidthx_t) (GLfixed); +typedef void (* glLoadIdentity_t) (); +typedef void (* glLoadMatrixx_t) (const GLfixed*); +typedef void (* glLogicOp_t) (GLenum); +typedef void (* glMaterialx_t) (GLenum, GLenum, GLfixed); +typedef void (* glMaterialxv_t) (GLenum, GLenum, const GLfixed*); +typedef void (* glMatrixMode_t) (GLenum); +typedef void (* glMultMatrixx_t) (const GLfixed*); +typedef void (* glMultiTexCoord4x_t) (GLenum, GLfixed, GLfixed, GLfixed, GLfixed); +typedef void (* glNormal3x_t) (GLfixed, GLfixed, GLfixed); +typedef void (* glNormalPointer_t) (GLenum, GLsizei, const GLvoid*); +typedef void (* glOrthox_t) (GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed); +typedef void (* glPixelStorei_t) (GLenum, GLint); +typedef void (* glPointParameterx_t) (GLenum, GLfixed); +typedef void (* glPointParameterxv_t) (GLenum, const GLfixed*); +typedef void (* glPointSizex_t) (GLfixed); +typedef void (* glPolygonOffsetx_t) (GLfixed, GLfixed); +typedef void (* glPopMatrix_t) (); +typedef void (* glPushMatrix_t) (); +typedef void (* glReadPixels_t) (GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, GLvoid*); +typedef void (* glRotatex_t) (GLfixed, GLfixed, GLfixed, GLfixed); +typedef void (* glSampleCoverage_t) (GLclampf, GLboolean); +typedef void (* glSampleCoveragex_t) (GLclampx, GLboolean); +typedef void (* glScalex_t) (GLfixed, GLfixed, GLfixed); +typedef void (* glScissor_t) (GLint, GLint, GLsizei, GLsizei); +typedef void (* glShadeModel_t) (GLenum); +typedef void (* glStencilFunc_t) (GLenum, GLint, GLuint); +typedef void (* glStencilMask_t) (GLuint); +typedef void (* glStencilOp_t) (GLenum, GLenum, GLenum); +typedef void (* glTexCoordPointer_t) (GLint, GLenum, GLsizei, const GLvoid*); +typedef void (* glTexEnvi_t) (GLenum, GLenum, GLint); +typedef void (* glTexEnvx_t) (GLenum, GLenum, GLfixed); +typedef void (* glTexEnviv_t) (GLenum, GLenum, const GLint*); +typedef void (* glTexEnvxv_t) (GLenum, GLenum, const GLfixed*); +typedef void (* glTexImage2D_t) (GLenum, GLint, GLint, GLsizei, GLsizei, GLint, GLenum, GLenum, const GLvoid*); +typedef void (* glTexParameteri_t) (GLenum, GLenum, GLint); +typedef void (* glTexParameterx_t) (GLenum, GLenum, GLfixed); +typedef void (* glTexParameteriv_t) (GLenum, GLenum, const GLint*); +typedef void (* glTexParameterxv_t) (GLenum, GLenum, const GLfixed*); +typedef void (* glTexSubImage2D_t) (GLenum, GLint, GLint, GLint, GLsizei, GLsizei, GLenum, GLenum, const GLvoid*); +typedef void (* glTranslatex_t) (GLfixed, GLfixed, GLfixed); +typedef void (* glVertexPointer_t) (GLint, GLenum, GLsizei, const GLvoid*); +typedef void (* glViewport_t) (GLint, GLint, GLsizei, GLsizei); +typedef void (* glPointSizePointerOES_t) (GLenum, GLsizei, const GLvoid*); +typedef void (* glBlendEquationSeparateOES_t) (GLenum, GLenum); +typedef void (* glBlendFuncSeparateOES_t) (GLenum, GLenum, GLenum, GLenum); +typedef void (* glBlendEquationOES_t) (GLenum); +typedef void (* glDrawTexsOES_t) (GLshort, GLshort, GLshort, GLshort, GLshort); +typedef void (* glDrawTexiOES_t) (GLint, GLint, GLint, GLint, GLint); +typedef void (* glDrawTexxOES_t) (GLfixed, GLfixed, GLfixed, GLfixed, GLfixed); +typedef void (* glDrawTexsvOES_t) (const GLshort*); +typedef void (* glDrawTexivOES_t) (const GLint*); +typedef void (* glDrawTexxvOES_t) (const GLfixed*); +typedef void (* glDrawTexfOES_t) (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); +typedef void (* glDrawTexfvOES_t) (const GLfloat*); +typedef void (* glEGLImageTargetTexture2DOES_t) (GLenum, GLeglImageOES); +typedef void (* glEGLImageTargetRenderbufferStorageOES_t) (GLenum, GLeglImageOES); +typedef void (* glAlphaFuncxOES_t) (GLenum, GLclampx); +typedef void (* glClearColorxOES_t) (GLclampx, GLclampx, GLclampx, GLclampx); +typedef void (* glClearDepthxOES_t) (GLclampx); +typedef void (* glClipPlanexOES_t) (GLenum, const GLfixed*); +typedef void (* glColor4xOES_t) (GLfixed, GLfixed, GLfixed, GLfixed); +typedef void (* glDepthRangexOES_t) (GLclampx, GLclampx); +typedef void (* glFogxOES_t) (GLenum, GLfixed); +typedef void (* glFogxvOES_t) (GLenum, const GLfixed*); +typedef void (* glFrustumxOES_t) (GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed); +typedef void (* glGetClipPlanexOES_t) (GLenum, GLfixed*); +typedef void (* glGetFixedvOES_t) (GLenum, GLfixed*); +typedef void (* glGetLightxvOES_t) (GLenum, GLenum, GLfixed*); +typedef void (* glGetMaterialxvOES_t) (GLenum, GLenum, GLfixed*); +typedef void (* glGetTexEnvxvOES_t) (GLenum, GLenum, GLfixed*); +typedef void (* glGetTexParameterxvOES_t) (GLenum, GLenum, GLfixed*); +typedef void (* glLightModelxOES_t) (GLenum, GLfixed); +typedef void (* glLightModelxvOES_t) (GLenum, const GLfixed*); +typedef void (* glLightxOES_t) (GLenum, GLenum, GLfixed); +typedef void (* glLightxvOES_t) (GLenum, GLenum, const GLfixed*); +typedef void (* glLineWidthxOES_t) (GLfixed); +typedef void (* glLoadMatrixxOES_t) (const GLfixed*); +typedef void (* glMaterialxOES_t) (GLenum, GLenum, GLfixed); +typedef void (* glMaterialxvOES_t) (GLenum, GLenum, const GLfixed*); +typedef void (* glMultMatrixxOES_t) (const GLfixed*); +typedef void (* glMultiTexCoord4xOES_t) (GLenum, GLfixed, GLfixed, GLfixed, GLfixed); +typedef void (* glNormal3xOES_t) (GLfixed, GLfixed, GLfixed); +typedef void (* glOrthoxOES_t) (GLfixed, GLfixed, GLfixed, GLfixed, GLfixed, GLfixed); +typedef void (* glPointParameterxOES_t) (GLenum, GLfixed); +typedef void (* glPointParameterxvOES_t) (GLenum, const GLfixed*); +typedef void (* glPointSizexOES_t) (GLfixed); +typedef void (* glPolygonOffsetxOES_t) (GLfixed, GLfixed); +typedef void (* glRotatexOES_t) (GLfixed, GLfixed, GLfixed, GLfixed); +typedef void (* glSampleCoveragexOES_t) (GLclampx, GLboolean); +typedef void (* glScalexOES_t) (GLfixed, GLfixed, GLfixed); +typedef void (* glTexEnvxOES_t) (GLenum, GLenum, GLfixed); +typedef void (* glTexEnvxvOES_t) (GLenum, GLenum, const GLfixed*); +typedef void (* glTexParameterxOES_t) (GLenum, GLenum, GLfixed); +typedef void (* glTexParameterxvOES_t) (GLenum, GLenum, const GLfixed*); +typedef void (* glTranslatexOES_t) (GLfixed, GLfixed, GLfixed); +typedef GLboolean (* glIsRenderbufferOES_t) (GLuint); +typedef void (* glBindRenderbufferOES_t) (GLenum, GLuint); +typedef void (* glDeleteRenderbuffersOES_t) (GLsizei, const GLuint*); +typedef void (* glGenRenderbuffersOES_t) (GLsizei, GLuint*); +typedef void (* glRenderbufferStorageOES_t) (GLenum, GLenum, GLsizei, GLsizei); +typedef void (* glGetRenderbufferParameterivOES_t) (GLenum, GLenum, GLint*); +typedef GLboolean (* glIsFramebufferOES_t) (GLuint); +typedef void (* glBindFramebufferOES_t) (GLenum, GLuint); +typedef void (* glDeleteFramebuffersOES_t) (GLsizei, const GLuint*); +typedef void (* glGenFramebuffersOES_t) (GLsizei, GLuint*); +typedef GLenum (* glCheckFramebufferStatusOES_t) (GLenum); +typedef void (* glFramebufferRenderbufferOES_t) (GLenum, GLenum, GLenum, GLuint); +typedef void (* glFramebufferTexture2DOES_t) (GLenum, GLenum, GLenum, GLuint, GLint); +typedef void (* glGetFramebufferAttachmentParameterivOES_t) (GLenum, GLenum, GLenum, GLint*); +typedef void (* glGenerateMipmapOES_t) (GLenum); +typedef void* (* glMapBufferOES_t) (GLenum, GLenum); +typedef GLboolean (* glUnmapBufferOES_t) (GLenum); +typedef void (* glGetBufferPointervOES_t) (GLenum, GLenum, GLvoid*); +typedef void (* glCurrentPaletteMatrixOES_t) (GLuint); +typedef void (* glLoadPaletteFromModelViewMatrixOES_t) (); +typedef void (* glMatrixIndexPointerOES_t) (GLint, GLenum, GLsizei, const GLvoid*); +typedef void (* glWeightPointerOES_t) (GLint, GLenum, GLsizei, const GLvoid*); +typedef GLbitfield (* glQueryMatrixxOES_t) (GLfixed*, GLint*); +typedef void (* glDepthRangefOES_t) (GLclampf, GLclampf); +typedef void (* glFrustumfOES_t) (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); +typedef void (* glOrthofOES_t) (GLfloat, GLfloat, GLfloat, GLfloat, GLfloat, GLfloat); +typedef void (* glClipPlanefOES_t) (GLenum, const GLfloat*); +typedef void (* glGetClipPlanefOES_t) (GLenum, GLfloat*); +typedef void (* glClearDepthfOES_t) (GLclampf); +typedef void (* glTexGenfOES_t) (GLenum, GLenum, GLfloat); +typedef void (* glTexGenfvOES_t) (GLenum, GLenum, const GLfloat*); +typedef void (* glTexGeniOES_t) (GLenum, GLenum, GLint); +typedef void (* glTexGenivOES_t) (GLenum, GLenum, const GLint*); +typedef void (* glTexGenxOES_t) (GLenum, GLenum, GLfixed); +typedef void (* glTexGenxvOES_t) (GLenum, GLenum, const GLfixed*); +typedef void (* glGetTexGenfvOES_t) (GLenum, GLenum, GLfloat*); +typedef void (* glGetTexGenivOES_t) (GLenum, GLenum, GLint*); +typedef void (* glGetTexGenxvOES_t) (GLenum, GLenum, GLfixed*); +typedef void (* glBindVertexArrayOES_t) (GLuint); +typedef void (* glDeleteVertexArraysOES_t) (GLsizei, const GLuint*); +typedef void (* glGenVertexArraysOES_t) (GLsizei, GLuint*); +typedef GLboolean (* glIsVertexArrayOES_t) (GLuint); +typedef void (* glDiscardFramebufferEXT_t) (GLenum, GLsizei, const GLenum*); +typedef void (* glMultiDrawArraysEXT_t) (GLenum, GLint*, GLsizei*, GLsizei); +typedef void (* glMultiDrawElementsEXT_t) (GLenum, const GLsizei*, GLenum, const GLvoid**, GLsizei); +typedef void (* glClipPlanefIMG_t) (GLenum, const GLfloat*); +typedef void (* glClipPlanexIMG_t) (GLenum, const GLfixed*); +typedef void (* glRenderbufferStorageMultisampleIMG_t) (GLenum, GLsizei, GLenum, GLsizei, GLsizei); +typedef void (* glFramebufferTexture2DMultisampleIMG_t) (GLenum, GLenum, GLenum, GLuint, GLint, GLsizei); +typedef void (* glDeleteFencesNV_t) (GLsizei, const GLuint*); +typedef void (* glGenFencesNV_t) (GLsizei, GLuint*); +typedef GLboolean (* glIsFenceNV_t) (GLuint); +typedef GLboolean (* glTestFenceNV_t) (GLuint); +typedef void (* glGetFenceivNV_t) (GLuint, GLenum, GLint*); +typedef void (* glFinishFenceNV_t) (GLuint); +typedef void (* glSetFenceNV_t) (GLuint, GLenum); +typedef void (* glGetDriverControlsQCOM_t) (GLint*, GLsizei, GLuint*); +typedef void (* glGetDriverControlStringQCOM_t) (GLuint, GLsizei, GLsizei*, GLchar*); +typedef void (* glEnableDriverControlQCOM_t) (GLuint); +typedef void (* glDisableDriverControlQCOM_t) (GLuint); +typedef void (* glExtGetTexturesQCOM_t) (GLuint*, GLint, GLint*); +typedef void (* glExtGetBuffersQCOM_t) (GLuint*, GLint, GLint*); +typedef void (* glExtGetRenderbuffersQCOM_t) (GLuint*, GLint, GLint*); +typedef void (* glExtGetFramebuffersQCOM_t) (GLuint*, GLint, GLint*); +typedef void (* glExtGetTexLevelParameterivQCOM_t) (GLuint, GLenum, GLint, GLenum, GLint*); +typedef void (* glExtTexObjectStateOverrideiQCOM_t) (GLenum, GLenum, GLint); +typedef void (* glExtGetTexSubImageQCOM_t) (GLenum, GLint, GLint, GLint, GLint, GLsizei, GLsizei, GLsizei, GLenum, GLenum, GLvoid*); +typedef void (* glExtGetBufferPointervQCOM_t) (GLenum, GLvoid**); +typedef void (* glExtGetShadersQCOM_t) (GLuint*, GLint, GLint*); +typedef void (* glExtGetProgramsQCOM_t) (GLuint*, GLint, GLint*); +typedef GLboolean (* glExtIsProgramBinaryQCOM_t) (GLuint); +typedef void (* glExtGetProgramBinarySourceQCOM_t) (GLuint, GLenum, GLchar*, GLint*); +typedef void (* glStartTilingQCOM_t) (GLuint, GLuint, GLuint, GLuint, GLbitfield); +typedef void (* glEndTilingQCOM_t) (GLbitfield); + + +#endif diff --git a/emulator/opengl/tests/gles_android_wrapper/glesv1_emul_ifc.cpp b/emulator/opengl/tests/gles_android_wrapper/glesv1_emul_ifc.cpp new file mode 100644 index 0000000..26c98a8 --- /dev/null +++ b/emulator/opengl/tests/gles_android_wrapper/glesv1_emul_ifc.cpp @@ -0,0 +1,39 @@ +/* +* Copyright 2011 The Android Open Source Project +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include <stdlib.h> +#include "ApiInitializer.h" +#include <dlfcn.h> +#include "gl_wrapper_context.h" + +extern "C" { + gl_wrapper_context_t *createFromLib(void *solib, gl_wrapper_context_t *(*accessor)()); +} + +gl_wrapper_context_t * createFromLib(void *solib, gl_wrapper_context_t *(accessor)()) +{ + gl_wrapper_context_t *ctx = new gl_wrapper_context_t; + if (ctx == NULL) { + return NULL; + } + ApiInitializer *initializer = new ApiInitializer(solib); + ctx->initDispatchByName(ApiInitializer::s_getProc, initializer); + gl_wrapper_context_t::setContextAccessor(accessor); + delete initializer; + return ctx; +} + + diff --git a/emulator/opengl/tests/gles_android_wrapper/glesv2_emul_ifc.cpp b/emulator/opengl/tests/gles_android_wrapper/glesv2_emul_ifc.cpp new file mode 100644 index 0000000..4ae13dd --- /dev/null +++ b/emulator/opengl/tests/gles_android_wrapper/glesv2_emul_ifc.cpp @@ -0,0 +1,40 @@ +/* +* Copyright 2011 The Android Open Source Project +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ + +#include <stdlib.h> +#include "ApiInitializer.h" +#include <dlfcn.h> +#include "gl2_wrapper_context.h" + +extern "C" { + gl2_wrapper_context_t *createFromLib(void *solib, gl2_wrapper_context_t *(*accessor)()); +} + +gl2_wrapper_context_t * createFromLib(void *solib, gl2_wrapper_context_t *(*accessor)()) +{ + gl2_wrapper_context_t *ctx = new gl2_wrapper_context_t; + if (ctx == NULL) { + return NULL; + } + ApiInitializer *initializer = new ApiInitializer(solib); + ctx->initDispatchByName(ApiInitializer::s_getProc, initializer); + gl2_wrapper_context_t::setContextAccessor(accessor); + delete initializer; + return ctx; +} + + + |