upload android base code part6
This commit is contained in:
August
parent
421e214c7d
commit
4e516ec6ed
35396 changed files with 9188716 additions and 0 deletions
|
|
@ -0,0 +1,74 @@
|
|||
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 full_mips sdk sdk_x86 sdk_mips,$(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_CLASS := ETC
|
||||
|
||||
include $(BUILD_PREBUILT)
|
||||
endif # building 'real' driver BUILD_EMULATOR_OPENGL_DRIVER
|
||||
endif # TARGET_PRODUCT in 'full sdk full_x86 sdk_x86 full_mips sdk_mips'
|
||||
|
||||
#### gles_emul.cfg ####
|
||||
include $(CLEAR_VARS)
|
||||
|
||||
LOCAL_MODULE := gles_emul.cfg
|
||||
LOCAL_SRC_FILES := $(LOCAL_MODULE)
|
||||
|
||||
LOCAL_MODULE_PATH := $(TARGET_OUT)/etc
|
||||
LOCAL_MODULE_CLASS := ETC
|
||||
|
||||
include $(BUILD_PREBUILT)
|
||||
|
|
@ -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
|
||||
|
|
@ -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)
|
||||
|
|
@ -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;
|
||||
}
|
||||
|
||||
|
|
@ -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
|
||||
|
|
@ -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;
|
||||
}
|
||||
|
|
@ -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
|
||||
|
|
@ -0,0 +1 @@
|
|||
0 0 emul
|
||||
|
|
@ -0,0 +1,627 @@
|
|||
/*
|
||||
* 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/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 constexpr size_t kMaxProcessNameLength = 100;
|
||||
static const char procname[kMaxProcessNameLength]{0};
|
||||
|
||||
int rc = pthread_getname_np(pthread_self(), procname, kMaxProcessNameLength);
|
||||
|
||||
if (rc == 0) {
|
||||
return procname;
|
||||
}
|
||||
|
||||
return nullptr;
|
||||
}
|
||||
|
||||
|
||||
|
||||
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);
|
||||
}
|
||||
|
|
@ -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;
|
||||
}
|
||||
|
|
@ -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
|
||||
|
|
@ -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);
|
||||
|
|
@ -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
|
||||
File diff suppressed because it is too large
Load diff
|
|
@ -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;
|
||||
}
|
||||
|
|
@ -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
|
||||
|
|
@ -0,0 +1,7 @@
|
|||
angeles
|
||||
my-tritex
|
||||
org.zeroxlab.benchmark
|
||||
com.cooliris.media
|
||||
com.polarbit.waveblazerlite
|
||||
test-opengl-gl2_basic
|
||||
com.trendy.ddapp
|
||||
|
|
@ -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);
|
||||
|
|
@ -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
|
||||
|
|
@ -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;
|
||||
}
|
||||
|
||||
|
||||
|
|
@ -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;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,8 @@
|
|||
LOCAL_PATH := $(call my-dir)
|
||||
|
||||
$(call emugl-begin-shared-library,libut_rendercontrol_enc)
|
||||
$(call emugl-import,libOpenglCodecCommon)
|
||||
$(call emugl-gen-encoder,$(LOCAL_PATH),ut_rendercontrol)
|
||||
$(call emugl-export,C_INCLUDES,$(LOCAL_PATH))
|
||||
$(call emugl-end-module)
|
||||
|
||||
|
|
@ -0,0 +1,4 @@
|
|||
GLOBAL
|
||||
base_opcode 10000
|
||||
encoder_headers <stdint.h>
|
||||
|
||||
|
|
@ -0,0 +1,11 @@
|
|||
GL_ENTRY(int, createContext, uint32_t pid, uint32_t handle, uint32_t shareCtx, int version)
|
||||
GL_ENTRY(int, createSurface, uint32_t pid, uint32_t handle)
|
||||
GL_ENTRY(int, makeCurrentContext, uint32_t pid, uint32_t drawSurface, uint32_t readSurface, uint32_t ctxHandle)
|
||||
GL_ENTRY(void, swapBuffers, uint32_t pid, uint32_t surface)
|
||||
GL_ENTRY(int, destroyContext, uint32_t pid, uint32_t handle)
|
||||
GL_ENTRY(int, destroySurface, uint32_t pid, uint32_t handle)
|
||||
|
||||
|
||||
|
||||
|
||||
|
||||
|
|
@ -0,0 +1,2 @@
|
|||
uint32_t 32 0x%08x false
|
||||
|
||||
|
|
@ -0,0 +1,17 @@
|
|||
/*
|
||||
* 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 <stdint.h>
|
||||
Loading…
Add table
Add a link
Reference in a new issue