From af94ceb5df8c7ee21d84a58caa5f632663d4e1b0 Mon Sep 17 00:00:00 2001 From: David Li Date: Tue, 1 Mar 2011 16:54:04 -0800 Subject: Initial commit of libAgl2 using Pixelflinger2 in external/mesa3d Somewhat functional, refer to README for details. Need to enable Android.mk to build. It builds libGLES_android.so, which needs to replace the one in system/lib/egl built by libagl. Change-Id: Iec3aaa8f3963a4185d81955cd24019eb0c4a5850 Signed-off-by: David Li --- opengl/libagl2/Android.mk | 58 + opengl/libagl2/README | 26 + opengl/libagl2/libagl2.project | 108 ++ opengl/libagl2/src/api.cpp | 266 +++++ opengl/libagl2/src/egl.cpp | 2232 +++++++++++++++++++++++++++++++++++++ opengl/libagl2/src/get.cpp | 79 ++ opengl/libagl2/src/gles2context.h | 166 +++ opengl/libagl2/src/shader.cpp | 191 ++++ opengl/libagl2/src/state.cpp | 129 +++ opengl/libagl2/src/texture.cpp | 534 +++++++++ opengl/libagl2/src/vertex.cpp | 373 +++++++ 11 files changed, 4162 insertions(+) create mode 100644 opengl/libagl2/Android.mk create mode 100644 opengl/libagl2/README create mode 100644 opengl/libagl2/libagl2.project create mode 100644 opengl/libagl2/src/api.cpp create mode 100644 opengl/libagl2/src/egl.cpp create mode 100644 opengl/libagl2/src/get.cpp create mode 100644 opengl/libagl2/src/gles2context.h create mode 100644 opengl/libagl2/src/shader.cpp create mode 100644 opengl/libagl2/src/state.cpp create mode 100644 opengl/libagl2/src/texture.cpp create mode 100644 opengl/libagl2/src/vertex.cpp (limited to 'opengl') diff --git a/opengl/libagl2/Android.mk b/opengl/libagl2/Android.mk new file mode 100644 index 0000000..564932f --- /dev/null +++ b/opengl/libagl2/Android.mk @@ -0,0 +1,58 @@ +LOCAL_PATH:= $(call my-dir) + +# +# Build the software OpenGL ES library +# + +include $(CLEAR_VARS) + +LOCAL_SRC_FILES:= \ + src/api.cpp \ + src/egl.cpp \ + src/get.cpp \ + src/shader.cpp \ + src/state.cpp \ + src/texture.cpp \ + src/vertex.cpp + +LOCAL_C_INCLUDES := \ + $(LOCAL_PATH) \ + external/mesa3d/include \ + external/mesa3d/src \ + external/stlport/stlport \ + bionic + +#LOCAL_CFLAGS += -DLOG_TAG=\"libagl2\" +#LOCAL_CFLAGS += -DGL_GLEXT_PROTOTYPES -DEGL_EGLEXT_PROTOTYPES +#LOCAL_CFLAGS += -fvisibility=hidden +#LOCAL_CFLAGS += -O0 -g -DDEBUG -UNDEBUG +LOCAL_CFLAGS += -O3 +LOCAL_STATIC_LIBRARIES := libMesa +LOCAL_SHARED_LIBRARIES := libstlport libcutils libhardware libutils libbcc libdl +LOCAL_LDLIBS := -lpthread + +ifeq ($(TARGET_ARCH),arm) + LOCAL_CFLAGS += -fstrict-aliasing +endif + +ifeq ($(ARCH_ARM_HAVE_TLS_REGISTER),true) + LOCAL_CFLAGS += -DHAVE_ARM_TLS_REGISTER +endif + +ifneq ($(TARGET_SIMULATOR),true) + # we need to access the private Bionic header + # on ARM platforms, we need to mirror the ARCH_ARM_HAVE_TLS_REGISTER + # behavior from the bionic Android.mk file + ifeq ($(TARGET_ARCH)-$(ARCH_ARM_HAVE_TLS_REGISTER),arm-true) + LOCAL_CFLAGS += -DHAVE_ARM_TLS_REGISTER + endif + LOCAL_C_INCLUDES += bionic/libc/private +endif + +LOCAL_MODULE_PATH := $(TARGET_OUT_SHARED_LIBRARIES)/egl +#replace libagl for now +LOCAL_MODULE:= libGLES_android +LOCAL_MODULE_TAGS := eng + +## Disable this makefile for now +## include $(BUILD_SHARED_LIBRARY) diff --git a/opengl/libagl2/README b/opengl/libagl2/README new file mode 100644 index 0000000..34746d3 --- /dev/null +++ b/opengl/libagl2/README @@ -0,0 +1,26 @@ +libAgl2 provides software GL ES 2.0 implementation using Pixelflinger2 in external/mesa3d + +To build, enable Android.mk, which builds libGLES_android.so, then replace the one built from libAgl in system/lib/egl. +ES 1.0 functions are not implemented and will cause exit, so do not setprop debug.egl.hw 0 until launcher is loaded. + +All functions have little to none error checking. +Not thread safe, Pixelflinger2 uses some static data. + +Most shader functions are implemented, however, most Get* functions for shaders/programs/uniforms/attribs are not. +No name system for shaders/programs, just using the pointers as names. + +Basic glTexImage2D, glTexSubImage2D, glCopyImage2D and glCopySubImage2D are implemented, with a range of 8/16/24/32bpp formats. +Cube map support is minimal. No mipmapping. +TexParameter is mostly implemented, supports texcoord wrap modes, and only linear for both min and mag, or nearest for both min and mag filtering. +Texture names are implemented, but bad. + +Frame buffer and render buffers are not implemented. + +Depth and stencil are implemented, but not tested. +Blending seems to work. +Colorbuffer supports RGBA_8888 and RGB_565. + +Vertex buffer objects are implemented. +Some GL_TRIANGLES and GL_TRIANGLE_STRIPS modes for glDrawArrays and glDrawElements are implemented, but vertex order is probably wrong so culling is disabled. + +Basic apps should work, and some libhwui should work, except for frame buffer operations, which will cause exit. diff --git a/opengl/libagl2/libagl2.project b/opengl/libagl2/libagl2.project new file mode 100644 index 0000000..f234421 --- /dev/null +++ b/opengl/libagl2/libagl2.project @@ -0,0 +1,108 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + None + + + + + + + + + + + + + + + + + + + + + + + + + + + + None + + + + + + + + + + + + + + + + + + + + + diff --git a/opengl/libagl2/src/api.cpp b/opengl/libagl2/src/api.cpp new file mode 100644 index 0000000..bb8d62b --- /dev/null +++ b/opengl/libagl2/src/api.cpp @@ -0,0 +1,266 @@ +#include "gles2context.h" + +#define API_ENTRY +#define CALL_GL_API(NAME,...) LOGD("?"#NAME); assert(0); +#define CALL_GL_API_RETURN(NAME,...) LOGD("?"#NAME); assert(0); return 0; + + +void API_ENTRY(glBindFramebuffer)(GLenum target, GLuint framebuffer) +{ + CALL_GL_API(glBindFramebuffer, target, framebuffer); +} +void API_ENTRY(glBindRenderbuffer)(GLenum target, GLuint renderbuffer) +{ + CALL_GL_API(glBindRenderbuffer, target, renderbuffer); +} +GLenum API_ENTRY(glCheckFramebufferStatus)(GLenum target) +{ + CALL_GL_API_RETURN(glCheckFramebufferStatus, target); +} +void API_ENTRY(glColorMask)(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha) +{ + CALL_GL_API(glColorMask, red, green, blue, alpha); +} +void API_ENTRY(glDeleteFramebuffers)(GLsizei n, const GLuint* framebuffers) +{ + CALL_GL_API(glDeleteFramebuffers, n, framebuffers); +} +void API_ENTRY(glDeleteRenderbuffers)(GLsizei n, const GLuint* renderbuffers) +{ + CALL_GL_API(glDeleteRenderbuffers, n, renderbuffers); +} +void API_ENTRY(glDepthFunc)(GLenum func) +{ + CALL_GL_API(glDepthFunc, func); +} +void API_ENTRY(glDepthMask)(GLboolean flag) +{ + CALL_GL_API(glDepthMask, flag); +} +void API_ENTRY(glDepthRangef)(GLclampf zNear, GLclampf zFar) +{ + CALL_GL_API(glDepthRangef, zNear, zFar); +} +void API_ENTRY(glFramebufferRenderbuffer)(GLenum target, GLenum attachment, GLenum renderbuffertarget, GLuint renderbuffer) +{ + CALL_GL_API(glFramebufferRenderbuffer, target, attachment, renderbuffertarget, renderbuffer); +} +void API_ENTRY(glFramebufferTexture2D)(GLenum target, GLenum attachment, GLenum textarget, GLuint texture, GLint level) +{ + CALL_GL_API(glFramebufferTexture2D, target, attachment, textarget, texture, level); +} +void glGenerateMipmap(GLenum target) +{ + //CALL_GL_API(glGenerateMipmap, target); + LOGD("agl2: glGenerateMipmap not implemented"); +} +void API_ENTRY(glGenFramebuffers)(GLsizei n, GLuint* framebuffers) +{ + CALL_GL_API(glGenFramebuffers, n, framebuffers); +} +void API_ENTRY(glGenRenderbuffers)(GLsizei n, GLuint* renderbuffers) +{ + CALL_GL_API(glGenRenderbuffers, n, renderbuffers); +} +void API_ENTRY(glGetActiveAttrib)(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name) +{ + CALL_GL_API(glGetActiveAttrib, program, index, bufsize, length, size, type, name); +} +void API_ENTRY(glGetActiveUniform)(GLuint program, GLuint index, GLsizei bufsize, GLsizei* length, GLint* size, GLenum* type, GLchar* name) +{ + CALL_GL_API(glGetActiveUniform, program, index, bufsize, length, size, type, name); +} +void API_ENTRY(glGetAttachedShaders)(GLuint program, GLsizei maxcount, GLsizei* count, GLuint* shaders) +{ + CALL_GL_API(glGetAttachedShaders, program, maxcount, count, shaders); +} +void API_ENTRY(glGetBooleanv)(GLenum pname, GLboolean* params) +{ + CALL_GL_API(glGetBooleanv, pname, params); +} +void API_ENTRY(glGetBufferParameteriv)(GLenum target, GLenum pname, GLint* params) +{ + CALL_GL_API(glGetBufferParameteriv, target, pname, params); +} +GLenum glGetError(void) +{ + puts("agl2: glGetError"); + return GL_NO_ERROR; + //CALL_GL_API_RETURN(glGetError); +} +void API_ENTRY(glGetFloatv)(GLenum pname, GLfloat* params) +{ + CALL_GL_API(glGetFloatv, pname, params); +} +void API_ENTRY(glGetFramebufferAttachmentParameteriv)(GLenum target, GLenum attachment, GLenum pname, GLint* params) +{ + CALL_GL_API(glGetFramebufferAttachmentParameteriv, target, attachment, pname, params); +} +void API_ENTRY(glGetRenderbufferParameteriv)(GLenum target, GLenum pname, GLint* params) +{ + CALL_GL_API(glGetRenderbufferParameteriv, target, pname, params); +} +void API_ENTRY(glGetShaderPrecisionFormat)(GLenum shadertype, GLenum precisiontype, GLint* range, GLint* precision) +{ + CALL_GL_API(glGetShaderPrecisionFormat, shadertype, precisiontype, range, precision); +} +void API_ENTRY(glGetShaderSource)(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* source) +{ + CALL_GL_API(glGetShaderSource, shader, bufsize, length, source); +} +void API_ENTRY(glGetUniformfv)(GLuint program, GLint location, GLfloat* params) +{ + CALL_GL_API(glGetUniformfv, program, location, params); +} +void API_ENTRY(glGetUniformiv)(GLuint program, GLint location, GLint* params) +{ + CALL_GL_API(glGetUniformiv, program, location, params); +} +void API_ENTRY(glGetVertexAttribfv)(GLuint index, GLenum pname, GLfloat* params) +{ + CALL_GL_API(glGetVertexAttribfv, index, pname, params); +} +void API_ENTRY(glGetVertexAttribiv)(GLuint index, GLenum pname, GLint* params) +{ + CALL_GL_API(glGetVertexAttribiv, index, pname, params); +} +void API_ENTRY(glGetVertexAttribPointerv)(GLuint index, GLenum pname, GLvoid** pointer) +{ + CALL_GL_API(glGetVertexAttribPointerv, index, pname, pointer); +} +GLboolean API_ENTRY(glIsBuffer)(GLuint buffer) +{ + CALL_GL_API_RETURN(glIsBuffer, buffer); +} +GLboolean API_ENTRY(glIsEnabled)(GLenum cap) +{ + CALL_GL_API_RETURN(glIsEnabled, cap); +} +GLboolean API_ENTRY(glIsFramebuffer)(GLuint framebuffer) +{ + CALL_GL_API_RETURN(glIsFramebuffer, framebuffer); +} +GLboolean API_ENTRY(glIsProgram)(GLuint program) +{ + CALL_GL_API_RETURN(glIsProgram, program); +} +GLboolean API_ENTRY(glIsRenderbuffer)(GLuint renderbuffer) +{ + CALL_GL_API_RETURN(glIsRenderbuffer, renderbuffer); +} +GLboolean API_ENTRY(glIsShader)(GLuint shader) +{ + CALL_GL_API_RETURN(glIsShader, shader); +} +void API_ENTRY(glLineWidth)(GLfloat width) +{ + CALL_GL_API(glLineWidth, width); +} +void API_ENTRY(glPolygonOffset)(GLfloat factor, GLfloat units) +{ + CALL_GL_API(glPolygonOffset, factor, units); +} +void API_ENTRY(glReadPixels)(GLint x, GLint y, GLsizei width, GLsizei height, GLenum format, GLenum type, GLvoid* pixels) +{ + CALL_GL_API(glReadPixels, x, y, width, height, format, type, pixels); +} +void API_ENTRY(glReleaseShaderCompiler)(void) +{ + CALL_GL_API(glReleaseShaderCompiler); +} +void API_ENTRY(glRenderbufferStorage)(GLenum target, GLenum internalformat, GLsizei width, GLsizei height) +{ + CALL_GL_API(glRenderbufferStorage, target, internalformat, width, height); +} +void API_ENTRY(glSampleCoverage)(GLclampf value, GLboolean invert) +{ + CALL_GL_API(glSampleCoverage, value, invert); +} +void API_ENTRY(glShaderBinary)(GLsizei n, const GLuint* shaders, GLenum binaryformat, const GLvoid* binary, GLsizei length) +{ + CALL_GL_API(glShaderBinary, n, shaders, binaryformat, binary, length); +} +void API_ENTRY(glStencilFunc)(GLenum func, GLint ref, GLuint mask) +{ + CALL_GL_API(glStencilFunc, func, ref, mask); +} +void API_ENTRY(glStencilFuncSeparate)(GLenum face, GLenum func, GLint ref, GLuint mask) +{ + CALL_GL_API(glStencilFuncSeparate, face, func, ref, mask); +} +void API_ENTRY(glStencilMask)(GLuint mask) +{ + CALL_GL_API(glStencilMask, mask); +} +void API_ENTRY(glStencilMaskSeparate)(GLenum face, GLuint mask) +{ + CALL_GL_API(glStencilMaskSeparate, face, mask); +} +void API_ENTRY(glStencilOp)(GLenum fail, GLenum zfail, GLenum zpass) +{ + CALL_GL_API(glStencilOp, fail, zfail, zpass); +} +void API_ENTRY(glStencilOpSeparate)(GLenum face, GLenum fail, GLenum zfail, GLenum zpass) +{ + CALL_GL_API(glStencilOpSeparate, face, fail, zfail, zpass); +} +void API_ENTRY(glUniform1fv)(GLint location, GLsizei count, const GLfloat* v) +{ + CALL_GL_API(glUniform1fv, location, count, v); +} +void API_ENTRY(glUniform1iv)(GLint location, GLsizei count, const GLint* v) +{ + CALL_GL_API(glUniform1iv, location, count, v); +} +void API_ENTRY(glUniform2fv)(GLint location, GLsizei count, const GLfloat* v) +{ + CALL_GL_API(glUniform2fv, location, count, v); +} +void API_ENTRY(glUniform2i)(GLint location, GLint x, GLint y) +{ + CALL_GL_API(glUniform2i, location, x, y); +} +void API_ENTRY(glUniform2iv)(GLint location, GLsizei count, const GLint* v) +{ + CALL_GL_API(glUniform2iv, location, count, v); +} +void API_ENTRY(glUniform3f)(GLint location, GLfloat x, GLfloat y, GLfloat z) +{ + CALL_GL_API(glUniform3f, location, x, y, z); +} +void API_ENTRY(glUniform3fv)(GLint location, GLsizei count, const GLfloat* v) +{ + CALL_GL_API(glUniform3fv, location, count, v); +} +void API_ENTRY(glUniform3i)(GLint location, GLint x, GLint y, GLint z) +{ + CALL_GL_API(glUniform3i, location, x, y, z); +} +void API_ENTRY(glUniform3iv)(GLint location, GLsizei count, const GLint* v) +{ + CALL_GL_API(glUniform3iv, location, count, v); +} +void API_ENTRY(glUniform4fv)(GLint location, GLsizei count, const GLfloat* v) +{ + CALL_GL_API(glUniform4fv, location, count, v); +} +void API_ENTRY(glUniform4i)(GLint location, GLint x, GLint y, GLint z, GLint w) +{ + CALL_GL_API(glUniform4i, location, x, y, z, w); +} +void API_ENTRY(glUniform4iv)(GLint location, GLsizei count, const GLint* v) +{ + CALL_GL_API(glUniform4iv, location, count, v); +} +void API_ENTRY(glUniformMatrix2fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + CALL_GL_API(glUniformMatrix2fv, location, count, transpose, value); +} +void API_ENTRY(glUniformMatrix3fv)(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + CALL_GL_API(glUniformMatrix3fv, location, count, transpose, value); +} +void API_ENTRY(glValidateProgram)(GLuint program) +{ + CALL_GL_API(glValidateProgram, program); +} diff --git a/opengl/libagl2/src/egl.cpp b/opengl/libagl2/src/egl.cpp new file mode 100644 index 0000000..6184644 --- /dev/null +++ b/opengl/libagl2/src/egl.cpp @@ -0,0 +1,2232 @@ +/* +** +** Copyright 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. +*/ + +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + + +#include + +#include + +#include "gles2context.h" + +// ---------------------------------------------------------------------------- +namespace android +{ +// ---------------------------------------------------------------------------- + +const unsigned int NUM_DISPLAYS = 1; + +static pthread_mutex_t gInitMutex = PTHREAD_MUTEX_INITIALIZER; +static pthread_mutex_t gErrorKeyMutex = PTHREAD_MUTEX_INITIALIZER; +static pthread_key_t gEGLErrorKey = -1; +#ifndef HAVE_ANDROID_OS +namespace gl { +pthread_key_t gGLKey = -1; +}; // namespace gl +#endif + +template +static T setError(GLint error, T returnValue) +{ + if (ggl_unlikely(gEGLErrorKey == -1)) { + pthread_mutex_lock(&gErrorKeyMutex); + if (gEGLErrorKey == -1) + pthread_key_create(&gEGLErrorKey, NULL); + pthread_mutex_unlock(&gErrorKeyMutex); + } + pthread_setspecific(gEGLErrorKey, (void*)error); + return returnValue; +} + +static GLint getError() +{ + if (ggl_unlikely(gEGLErrorKey == -1)) + return EGL_SUCCESS; + GLint error = (GLint)pthread_getspecific(gEGLErrorKey); + if (error == 0) { + // The TLS key has been created by another thread, but the value for + // this thread has not been initialized. + return EGL_SUCCESS; + } + pthread_setspecific(gEGLErrorKey, (void*)EGL_SUCCESS); + return error; +} + +// ---------------------------------------------------------------------------- + +struct egl_display_t { + egl_display_t() : type(0), initialized(0) { } + + static egl_display_t& get_display(EGLDisplay dpy); + + static EGLBoolean is_valid(EGLDisplay dpy) { + return ((uintptr_t(dpy)-1U) >= NUM_DISPLAYS) ? EGL_FALSE : EGL_TRUE; + } + + NativeDisplayType type; + volatile int32_t initialized; +}; + +static egl_display_t gDisplays[NUM_DISPLAYS]; + +egl_display_t& egl_display_t::get_display(EGLDisplay dpy) +{ + return gDisplays[uintptr_t(dpy)-1U]; +} + +// ---------------------------------------------------------------------------- + +struct egl_surface_t { + enum { + PAGE_FLIP = 0x00000001, + MAGIC = 0x31415265 + }; + + uint32_t magic; + EGLDisplay dpy; + EGLConfig config; + EGLContext ctx; + + egl_surface_t(EGLDisplay dpy, EGLConfig config, int32_t depthFormat); + virtual ~egl_surface_t(); + bool isValid() const; + virtual bool initCheck() const = 0; + + virtual EGLBoolean bindDrawSurface(GLES2Context* gl) = 0; + virtual EGLBoolean bindReadSurface(GLES2Context* gl) = 0; + virtual EGLBoolean connect() { + return EGL_TRUE; + } + virtual void disconnect() {} + virtual EGLint getWidth() const = 0; + virtual EGLint getHeight() const = 0; + + virtual EGLint getHorizontalResolution() const; + virtual EGLint getVerticalResolution() const; + virtual EGLint getRefreshRate() const; + virtual EGLint getSwapBehavior() const; + virtual EGLBoolean swapBuffers(); + virtual EGLBoolean setSwapRectangle(EGLint l, EGLint t, EGLint w, EGLint h); +protected: + GGLSurface depth; +}; + +egl_surface_t::egl_surface_t(EGLDisplay dpy, + EGLConfig config, + int32_t depthFormat) + : magic(MAGIC), dpy(dpy), config(config), ctx(0) +{ + depth.version = sizeof(GGLSurface); + depth.data = 0; + depth.format = (GGLPixelFormat)depthFormat; +} +egl_surface_t::~egl_surface_t() +{ + magic = 0; + free(depth.data); +} +bool egl_surface_t::isValid() const +{ + LOGE_IF(magic != MAGIC, "invalid EGLSurface (%p)", this); + return magic == MAGIC; +} + +EGLBoolean egl_surface_t::swapBuffers() +{ + return EGL_FALSE; +} +EGLint egl_surface_t::getHorizontalResolution() const +{ + return (0 * EGL_DISPLAY_SCALING) * (1.0f / 25.4f); +} +EGLint egl_surface_t::getVerticalResolution() const +{ + return (0 * EGL_DISPLAY_SCALING) * (1.0f / 25.4f); +} +EGLint egl_surface_t::getRefreshRate() const +{ + return (60 * EGL_DISPLAY_SCALING); +} +EGLint egl_surface_t::getSwapBehavior() const +{ + return EGL_BUFFER_PRESERVED; +} +EGLBoolean egl_surface_t::setSwapRectangle( + EGLint l, EGLint t, EGLint w, EGLint h) +{ + return EGL_FALSE; +} + +// ---------------------------------------------------------------------------- + +struct egl_window_surface_v2_t : public egl_surface_t { + egl_window_surface_v2_t( + EGLDisplay dpy, EGLConfig config, + int32_t depthFormat, + ANativeWindow* window); + + ~egl_window_surface_v2_t(); + + virtual bool initCheck() const { + return true; // TODO: report failure if ctor fails + } + virtual EGLBoolean swapBuffers(); + virtual EGLBoolean bindDrawSurface(GLES2Context* gl); + virtual EGLBoolean bindReadSurface(GLES2Context* gl); + virtual EGLBoolean connect(); + virtual void disconnect(); + virtual EGLint getWidth() const { + return width; + } + virtual EGLint getHeight() const { + return height; + } + virtual EGLint getHorizontalResolution() const; + virtual EGLint getVerticalResolution() const; + virtual EGLint getRefreshRate() const; + virtual EGLint getSwapBehavior() const; + virtual EGLBoolean setSwapRectangle(EGLint l, EGLint t, EGLint w, EGLint h); + +private: + status_t lock(android_native_buffer_t* buf, int usage, void** vaddr); + status_t unlock(android_native_buffer_t* buf); + ANativeWindow* nativeWindow; + android_native_buffer_t* buffer; + android_native_buffer_t* previousBuffer; + gralloc_module_t const* module; + copybit_device_t* blitengine; + int width; + int height; + void* bits; + GGLFormat const* pixelFormatTable; + + struct Rect { + inline Rect() { }; + inline Rect(int32_t w, int32_t h) + : left(0), top(0), right(w), bottom(h) { } + inline Rect(int32_t l, int32_t t, int32_t r, int32_t b) + : left(l), top(t), right(r), bottom(b) { } + Rect& andSelf(const Rect& r) { + left = max(left, r.left); + top = max(top, r.top); + right = min(right, r.right); + bottom = min(bottom, r.bottom); + return *this; + } + bool isEmpty() const { + return (left>=right || top>=bottom); + } + void dump(char const* what) { + LOGD("%s { %5d, %5d, w=%5d, h=%5d }", + what, left, top, right-left, bottom-top); + } + + int32_t left; + int32_t top; + int32_t right; + int32_t bottom; + }; + + struct Region { + inline Region() : count(0) { } + typedef Rect const* const_iterator; + const_iterator begin() const { + return storage; + } + const_iterator end() const { + return storage+count; + } + static Region subtract(const Rect& lhs, const Rect& rhs) { + Region reg; + Rect* storage = reg.storage; + if (!lhs.isEmpty()) { + if (lhs.top < rhs.top) { // top rect + storage->left = lhs.left; + storage->top = lhs.top; + storage->right = lhs.right; + storage->bottom = rhs.top; + storage++; + } + const int32_t top = max(lhs.top, rhs.top); + const int32_t bot = min(lhs.bottom, rhs.bottom); + if (top < bot) { + if (lhs.left < rhs.left) { // left-side rect + storage->left = lhs.left; + storage->top = top; + storage->right = rhs.left; + storage->bottom = bot; + storage++; + } + if (lhs.right > rhs.right) { // right-side rect + storage->left = rhs.right; + storage->top = top; + storage->right = lhs.right; + storage->bottom = bot; + storage++; + } + } + if (lhs.bottom > rhs.bottom) { // bottom rect + storage->left = lhs.left; + storage->top = rhs.bottom; + storage->right = lhs.right; + storage->bottom = lhs.bottom; + storage++; + } + reg.count = storage - reg.storage; + } + return reg; + } + bool isEmpty() const { + return count<=0; + } +private: + Rect storage[4]; + ssize_t count; + }; + + struct region_iterator : public copybit_region_t { + region_iterator(const Region& region) + : b(region.begin()), e(region.end()) { + this->next = iterate; + } +private: + static int iterate(copybit_region_t const * self, copybit_rect_t* rect) { + region_iterator const* me = static_cast(self); + if (me->b != me->e) { + *reinterpret_cast(rect) = *me->b++; + return 1; + } + return 0; + } + mutable Region::const_iterator b; + Region::const_iterator const e; + }; + + void copyBlt( + android_native_buffer_t* dst, void* dst_vaddr, + android_native_buffer_t* src, void const* src_vaddr, + const Region& clip); + + Rect dirtyRegion; + Rect oldDirtyRegion; +}; + +egl_window_surface_v2_t::egl_window_surface_v2_t(EGLDisplay dpy, + EGLConfig config, + int32_t depthFormat, + ANativeWindow* window) + : egl_surface_t(dpy, config, depthFormat), + nativeWindow(window), buffer(0), previousBuffer(0), module(0), + blitengine(0), bits(NULL) +{ + hw_module_t const* pModule; + hw_get_module(GRALLOC_HARDWARE_MODULE_ID, &pModule); + module = reinterpret_cast(pModule); + + if (hw_get_module(COPYBIT_HARDWARE_MODULE_ID, &pModule) == 0) { + copybit_open(pModule, &blitengine); + } + + pixelFormatTable = gglGetPixelFormatTable(); + + // keep a reference on the window + nativeWindow->common.incRef(&nativeWindow->common); + nativeWindow->query(nativeWindow, NATIVE_WINDOW_WIDTH, &width); + nativeWindow->query(nativeWindow, NATIVE_WINDOW_HEIGHT, &height); + int format = 0; + nativeWindow->query(nativeWindow, NATIVE_WINDOW_FORMAT, &format); + LOGD("agl2: egl_window_surface_v2_t format=0x%.4X", format); +// assert(0); +} + +egl_window_surface_v2_t::~egl_window_surface_v2_t() +{ + if (buffer) { + buffer->common.decRef(&buffer->common); + } + if (previousBuffer) { + previousBuffer->common.decRef(&previousBuffer->common); + } + nativeWindow->common.decRef(&nativeWindow->common); + if (blitengine) { + copybit_close(blitengine); + } +} + +EGLBoolean egl_window_surface_v2_t::connect() +{ + // we're intending to do software rendering + native_window_set_usage(nativeWindow, + GRALLOC_USAGE_SW_READ_OFTEN | GRALLOC_USAGE_SW_WRITE_OFTEN); + + // dequeue a buffer + if (nativeWindow->dequeueBuffer(nativeWindow, &buffer) != NO_ERROR) { + return setError(EGL_BAD_ALLOC, EGL_FALSE); + } + + // allocate a corresponding depth-buffer + width = buffer->width; + height = buffer->height; + if (depth.format) { + depth.width = width; + depth.height = height; + depth.stride = depth.width; // use the width here + assert(GGL_PIXEL_FORMAT_Z_32 == depth.format); + depth.data = (GGLubyte*)malloc(depth.stride*depth.height*4); + if (depth.data == 0) { + return setError(EGL_BAD_ALLOC, EGL_FALSE); + } + } + + // keep a reference on the buffer + buffer->common.incRef(&buffer->common); + + // Lock the buffer + nativeWindow->lockBuffer(nativeWindow, buffer); + // pin the buffer down + if (lock(buffer, GRALLOC_USAGE_SW_READ_OFTEN | + GRALLOC_USAGE_SW_WRITE_OFTEN, &bits) != NO_ERROR) { + LOGE("connect() failed to lock buffer %p (%ux%u)", + buffer, buffer->width, buffer->height); + return setError(EGL_BAD_ACCESS, EGL_FALSE); + // FIXME: we should make sure we're not accessing the buffer anymore + } + return EGL_TRUE; +} + +void egl_window_surface_v2_t::disconnect() +{ + if (buffer && bits) { + bits = NULL; + unlock(buffer); + } + // enqueue the last frame + if (buffer) + nativeWindow->queueBuffer(nativeWindow, buffer); + if (buffer) { + buffer->common.decRef(&buffer->common); + buffer = 0; + } + if (previousBuffer) { + previousBuffer->common.decRef(&previousBuffer->common); + previousBuffer = 0; + } +} + +status_t egl_window_surface_v2_t::lock( + android_native_buffer_t* buf, int usage, void** vaddr) +{ + int err; + + err = module->lock(module, buf->handle, + usage, 0, 0, buf->width, buf->height, vaddr); + + return err; +} + +status_t egl_window_surface_v2_t::unlock(android_native_buffer_t* buf) +{ + if (!buf) return BAD_VALUE; + int err = NO_ERROR; + + err = module->unlock(module, buf->handle); + + return err; +} + +void egl_window_surface_v2_t::copyBlt( + android_native_buffer_t* dst, void* dst_vaddr, + android_native_buffer_t* src, void const* src_vaddr, + const Region& clip) +{ + // FIXME: use copybit if possible + // NOTE: dst and src must be the same format + + status_t err = NO_ERROR; + copybit_device_t* const copybit = blitengine; + if (copybit) { + copybit_image_t simg; + simg.w = src->stride; + simg.h = src->height; + simg.format = src->format; + simg.handle = const_cast(src->handle); + + copybit_image_t dimg; + dimg.w = dst->stride; + dimg.h = dst->height; + dimg.format = dst->format; + dimg.handle = const_cast(dst->handle); + + copybit->set_parameter(copybit, COPYBIT_TRANSFORM, 0); + copybit->set_parameter(copybit, COPYBIT_PLANE_ALPHA, 255); + copybit->set_parameter(copybit, COPYBIT_DITHER, COPYBIT_DISABLE); + region_iterator it(clip); + err = copybit->blit(copybit, &dimg, &simg, &it); + if (err != NO_ERROR) { + LOGE("copybit failed (%s)", strerror(err)); + } + } + + if (!copybit || err) { + Region::const_iterator cur = clip.begin(); + Region::const_iterator end = clip.end(); + + const size_t bpp = pixelFormatTable[src->format].size; + const size_t dbpr = dst->stride * bpp; + const size_t sbpr = src->stride * bpp; + + uint8_t const * const src_bits = (uint8_t const *)src_vaddr; + uint8_t * const dst_bits = (uint8_t *)dst_vaddr; + + while (cur != end) { + const Rect& r(*cur++); + ssize_t w = r.right - r.left; + ssize_t h = r.bottom - r.top; + if (w <= 0 || h<=0) continue; + size_t size = w * bpp; + uint8_t const * s = src_bits + (r.left + src->stride * r.top) * bpp; + uint8_t * d = dst_bits + (r.left + dst->stride * r.top) * bpp; + if (dbpr==sbpr && size==sbpr) { + size *= h; + h = 1; + } + do { + memcpy(d, s, size); + d += dbpr; + s += sbpr; + } while (--h > 0); + } + } +} + +EGLBoolean egl_window_surface_v2_t::swapBuffers() +{ + if (!buffer) { + return setError(EGL_BAD_ACCESS, EGL_FALSE); + } + + /* + * Handle eglSetSwapRectangleANDROID() + * We copyback from the front buffer + */ + if (!dirtyRegion.isEmpty()) { + dirtyRegion.andSelf(Rect(buffer->width, buffer->height)); + if (previousBuffer) { + // This was const Region copyBack, but that causes an + // internal compile error on simulator builds + /*const*/ + Region copyBack(Region::subtract(oldDirtyRegion, dirtyRegion)); + if (!copyBack.isEmpty()) { + void* prevBits; + if (lock(previousBuffer, + GRALLOC_USAGE_SW_READ_OFTEN, &prevBits) == NO_ERROR) { + // copy from previousBuffer to buffer + copyBlt(buffer, bits, previousBuffer, prevBits, copyBack); + unlock(previousBuffer); + } + } + } + oldDirtyRegion = dirtyRegion; + } + + if (previousBuffer) { + previousBuffer->common.decRef(&previousBuffer->common); + previousBuffer = 0; + } + + unlock(buffer); + previousBuffer = buffer; + nativeWindow->queueBuffer(nativeWindow, buffer); + buffer = 0; + + // dequeue a new buffer + if (nativeWindow->dequeueBuffer(nativeWindow, &buffer) == NO_ERROR) { + + // TODO: lockBuffer should rather be executed when the very first + // direct rendering occurs. + nativeWindow->lockBuffer(nativeWindow, buffer); + + // reallocate the depth-buffer if needed + if ((width != buffer->width) || (height != buffer->height)) { + // TODO: we probably should reset the swap rect here + // if the window size has changed + width = buffer->width; + height = buffer->height; + if (depth.data) { + free(depth.data); + depth.width = width; + depth.height = height; + depth.stride = buffer->stride; + depth.data = (GGLubyte*)malloc(depth.stride*depth.height*2); + if (depth.data == 0) { + setError(EGL_BAD_ALLOC, EGL_FALSE); + return EGL_FALSE; + } + } + } + + // keep a reference on the buffer + buffer->common.incRef(&buffer->common); + + // finally pin the buffer down + if (lock(buffer, GRALLOC_USAGE_SW_READ_OFTEN | + GRALLOC_USAGE_SW_WRITE_OFTEN, &bits) != NO_ERROR) { + LOGE("eglSwapBuffers() failed to lock buffer %p (%ux%u)", + buffer, buffer->width, buffer->height); + return setError(EGL_BAD_ACCESS, EGL_FALSE); + // FIXME: we should make sure we're not accessing the buffer anymore + } + } else { + return setError(EGL_BAD_CURRENT_SURFACE, EGL_FALSE); + } + + return EGL_TRUE; +} + +EGLBoolean egl_window_surface_v2_t::setSwapRectangle( + EGLint l, EGLint t, EGLint w, EGLint h) +{ + dirtyRegion = Rect(l, t, l+w, t+h); + return EGL_TRUE; +} + +EGLBoolean egl_window_surface_v2_t::bindDrawSurface(GLES2Context* gl) +{ + GGLSurface buffer; + buffer.version = sizeof(GGLSurface); + buffer.width = this->buffer->width; + buffer.height = this->buffer->height; + buffer.stride = this->buffer->stride; + buffer.data = (GGLubyte*)bits; + buffer.format = (GGLPixelFormat)this->buffer->format; + gl->rasterizer.interface.SetBuffer(&gl->rasterizer.interface, GL_COLOR_BUFFER_BIT, &buffer); + if (depth.data != gl->rasterizer.depthSurface.data) + gl->rasterizer.interface.SetBuffer(&gl->rasterizer.interface, GL_DEPTH_BUFFER_BIT, &depth); + + return EGL_TRUE; +} +EGLBoolean egl_window_surface_v2_t::bindReadSurface(GLES2Context* gl) +{ + GGLSurface buffer; + buffer.version = sizeof(GGLSurface); + buffer.width = this->buffer->width; + buffer.height = this->buffer->height; + buffer.stride = this->buffer->stride; + buffer.data = (GGLubyte*)bits; // FIXME: hopefully is is LOCKED!!! + buffer.format = (GGLPixelFormat)this->buffer->format; + puts("agl2: readBuffer not implemented"); + //gl->rasterizer.interface.readBuffer(gl, &buffer); + return EGL_TRUE; +} +EGLint egl_window_surface_v2_t::getHorizontalResolution() const +{ + return (nativeWindow->xdpi * EGL_DISPLAY_SCALING) * (1.0f / 25.4f); +} +EGLint egl_window_surface_v2_t::getVerticalResolution() const +{ + return (nativeWindow->ydpi * EGL_DISPLAY_SCALING) * (1.0f / 25.4f); +} +EGLint egl_window_surface_v2_t::getRefreshRate() const +{ + return (60 * EGL_DISPLAY_SCALING); // FIXME +} +EGLint egl_window_surface_v2_t::getSwapBehavior() const +{ + /* + * EGL_BUFFER_PRESERVED means that eglSwapBuffers() completely preserves + * the content of the swapped buffer. + * + * EGL_BUFFER_DESTROYED means that the content of the buffer is lost. + * + * However when ANDROID_swap_retcangle is supported, EGL_BUFFER_DESTROYED + * only applies to the area specified by eglSetSwapRectangleANDROID(), that + * is, everything outside of this area is preserved. + * + * This implementation of EGL assumes the later case. + * + */ + + return EGL_BUFFER_DESTROYED; +} + +// ---------------------------------------------------------------------------- + +struct egl_pixmap_surface_t : public egl_surface_t { + egl_pixmap_surface_t( + EGLDisplay dpy, EGLConfig config, + int32_t depthFormat, + egl_native_pixmap_t const * pixmap); + + virtual ~egl_pixmap_surface_t() { } + + virtual bool initCheck() const { + return !depth.format || depth.data!=0; + } + virtual EGLBoolean bindDrawSurface(GLES2Context* gl); + virtual EGLBoolean bindReadSurface(GLES2Context* gl); + virtual EGLint getWidth() const { + return nativePixmap.width; + } + virtual EGLint getHeight() const { + return nativePixmap.height; + } +private: + egl_native_pixmap_t nativePixmap; +}; + +egl_pixmap_surface_t::egl_pixmap_surface_t(EGLDisplay dpy, + EGLConfig config, + int32_t depthFormat, + egl_native_pixmap_t const * pixmap) + : egl_surface_t(dpy, config, depthFormat), nativePixmap(*pixmap) +{ + if (depthFormat) { + depth.width = pixmap->width; + depth.height = pixmap->height; + depth.stride = depth.width; // use the width here + depth.data = (GGLubyte*)malloc(depth.stride*depth.height*2); + if (depth.data == 0) { + setError(EGL_BAD_ALLOC, EGL_NO_SURFACE); + } + } +} +EGLBoolean egl_pixmap_surface_t::bindDrawSurface(GLES2Context* gl) +{ + GGLSurface buffer; + buffer.version = sizeof(GGLSurface); + buffer.width = nativePixmap.width; + buffer.height = nativePixmap.height; + buffer.stride = nativePixmap.stride; + buffer.data = nativePixmap.data; + buffer.format = (GGLPixelFormat)nativePixmap.format; + + gl->rasterizer.interface.SetBuffer(&gl->rasterizer.interface, GL_COLOR_BUFFER_BIT, &buffer); + if (depth.data != gl->rasterizer.depthSurface.data) + gl->rasterizer.interface.SetBuffer(&gl->rasterizer.interface, GL_DEPTH_BUFFER_BIT, &depth); + return EGL_TRUE; +} +EGLBoolean egl_pixmap_surface_t::bindReadSurface(GLES2Context* gl) +{ + GGLSurface buffer; + buffer.version = sizeof(GGLSurface); + buffer.width = nativePixmap.width; + buffer.height = nativePixmap.height; + buffer.stride = nativePixmap.stride; + buffer.data = nativePixmap.data; + buffer.format = (GGLPixelFormat)nativePixmap.format; + puts("agl2: readBuffer not implemented"); + //gl->rasterizer.interface.readBuffer(gl, &buffer); + return EGL_TRUE; +} + +// ---------------------------------------------------------------------------- + +struct egl_pbuffer_surface_t : public egl_surface_t { + egl_pbuffer_surface_t( + EGLDisplay dpy, EGLConfig config, int32_t depthFormat, + int32_t w, int32_t h, int32_t f); + + virtual ~egl_pbuffer_surface_t(); + + virtual bool initCheck() const { + return pbuffer.data != 0; + } + virtual EGLBoolean bindDrawSurface(GLES2Context* gl); + virtual EGLBoolean bindReadSurface(GLES2Context* gl); + virtual EGLint getWidth() const { + return pbuffer.width; + } + virtual EGLint getHeight() const { + return pbuffer.height; + } +private: + GGLSurface pbuffer; +}; + +egl_pbuffer_surface_t::egl_pbuffer_surface_t(EGLDisplay dpy, + EGLConfig config, int32_t depthFormat, + int32_t w, int32_t h, int32_t f) + : egl_surface_t(dpy, config, depthFormat) +{ + size_t size = w*h; + switch (f) { + case GGL_PIXEL_FORMAT_A_8: + size *= 1; + break; + case GGL_PIXEL_FORMAT_RGB_565: + size *= 2; + break; + case GGL_PIXEL_FORMAT_RGBA_8888: + size *= 4; + break; + case GGL_PIXEL_FORMAT_RGBX_8888: + size *= 4; + break; + default: + LOGE("incompatible pixel format for pbuffer (format=%d)", f); + pbuffer.data = 0; + break; + } + pbuffer.version = sizeof(GGLSurface); + pbuffer.width = w; + pbuffer.height = h; + pbuffer.stride = w; + pbuffer.data = (GGLubyte*)malloc(size); + pbuffer.format = (GGLPixelFormat)f; + + if (depthFormat) { + depth.width = pbuffer.width; + depth.height = pbuffer.height; + depth.stride = depth.width; // use the width here + depth.data = (GGLubyte*)malloc(depth.stride*depth.height*2); + if (depth.data == 0) { + setError(EGL_BAD_ALLOC, EGL_NO_SURFACE); + return; + } + } +} +egl_pbuffer_surface_t::~egl_pbuffer_surface_t() +{ + free(pbuffer.data); +} +EGLBoolean egl_pbuffer_surface_t::bindDrawSurface(GLES2Context* gl) +{ + gl->rasterizer.interface.SetBuffer(&gl->rasterizer.interface, GL_COLOR_BUFFER_BIT, &pbuffer); + if (depth.data != gl->rasterizer.depthSurface.data) + gl->rasterizer.interface.SetBuffer(&gl->rasterizer.interface, GL_DEPTH_BUFFER_BIT, &depth); + return EGL_TRUE; +} +EGLBoolean egl_pbuffer_surface_t::bindReadSurface(GLES2Context* gl) +{ + puts("agl2: readBuffer not implemented"); + //gl->rasterizer.interface.readBuffer(gl, &pbuffer); + return EGL_TRUE; +} + +// ---------------------------------------------------------------------------- + +struct config_pair_t { + GLint key; + GLint value; +}; + +struct configs_t { + const config_pair_t* array; + int size; +}; + +struct config_management_t { + GLint key; + bool (*match)(GLint reqValue, GLint confValue); + static bool atLeast(GLint reqValue, GLint confValue) { + return (reqValue == EGL_DONT_CARE) || (confValue >= reqValue); + } + static bool exact(GLint reqValue, GLint confValue) { + return (reqValue == EGL_DONT_CARE) || (confValue == reqValue); + } + static bool mask(GLint reqValue, GLint confValue) { + return (confValue & reqValue) == reqValue; + } + static bool ignore(GLint reqValue, GLint confValue) { + return true; + } +}; + +// ---------------------------------------------------------------------------- + +#define VERSION_MAJOR 1 +#define VERSION_MINOR 2 +static char const * const gVendorString = "Google Inc."; +static char const * const gVersionString = "0.0 Android Driver 0.0.0"; +static char const * const gClientApiString = "OpenGL ES2"; +static char const * const gExtensionsString = + //"EGL_KHR_image_base " + // "KHR_image_pixmap " + //"EGL_ANDROID_image_native_buffer " + //"EGL_ANDROID_swap_rectangle " + ""; + +// ---------------------------------------------------------------------------- + +struct extention_map_t { + const char * const name; + __eglMustCastToProperFunctionPointerType address; +}; + +static const extention_map_t gExtentionMap[] = { +// { "glDrawTexsOES", +// (__eglMustCastToProperFunctionPointerType)&glDrawTexsOES }, +// { "glDrawTexiOES", +// (__eglMustCastToProperFunctionPointerType)&glDrawTexiOES }, +// { "glDrawTexfOES", +// (__eglMustCastToProperFunctionPointerType)&glDrawTexfOES }, +// { "glDrawTexxOES", +// (__eglMustCastToProperFunctionPointerType)&glDrawTexxOES }, +// { "glDrawTexsvOES", +// (__eglMustCastToProperFunctionPointerType)&glDrawTexsvOES }, +// { "glDrawTexivOES", +// (__eglMustCastToProperFunctionPointerType)&glDrawTexivOES }, +// { "glDrawTexfvOES", +// (__eglMustCastToProperFunctionPointerType)&glDrawTexfvOES }, +// { "glDrawTexxvOES", +// (__eglMustCastToProperFunctionPointerType)&glDrawTexxvOES }, +// { "glQueryMatrixxOES", +// (__eglMustCastToProperFunctionPointerType)&glQueryMatrixxOES }, +// { "glEGLImageTargetTexture2DOES", +// (__eglMustCastToProperFunctionPointerType)&glEGLImageTargetTexture2DOES }, +// { "glEGLImageTargetRenderbufferStorageOES", +// (__eglMustCastToProperFunctionPointerType)&glEGLImageTargetRenderbufferStorageOES }, +// { "glClipPlanef", +// (__eglMustCastToProperFunctionPointerType)&glClipPlanef }, +// { "glClipPlanex", +// (__eglMustCastToProperFunctionPointerType)&glClipPlanex }, +// { "glBindBuffer", +// (__eglMustCastToProperFunctionPointerType)&glBindBuffer }, +// { "glBufferData", +// (__eglMustCastToProperFunctionPointerType)&glBufferData }, +// { "glBufferSubData", +// (__eglMustCastToProperFunctionPointerType)&glBufferSubData }, +// { "glDeleteBuffers", +// (__eglMustCastToProperFunctionPointerType)&glDeleteBuffers }, +// { "glGenBuffers", +// (__eglMustCastToProperFunctionPointerType)&glGenBuffers }, +// { "eglCreateImageKHR", +// (__eglMustCastToProperFunctionPointerType)&eglCreateImageKHR }, +// { "eglDestroyImageKHR", +// (__eglMustCastToProperFunctionPointerType)&eglDestroyImageKHR }, +// { "eglSetSwapRectangleANDROID", +// (__eglMustCastToProperFunctionPointerType)&eglSetSwapRectangleANDROID }, +}; + +/* + * In the lists below, attributes names MUST be sorted. + * Additionally, all configs must be sorted according to + * the EGL specification. + */ + +static config_pair_t const config_base_attribute_list[] = { + { EGL_STENCIL_SIZE, 0 }, + { EGL_CONFIG_CAVEAT, EGL_SLOW_CONFIG }, + { EGL_LEVEL, 0 }, + { EGL_MAX_PBUFFER_HEIGHT, GGL_MAX_VIEWPORT_DIMS }, + { EGL_MAX_PBUFFER_PIXELS, + GGL_MAX_VIEWPORT_DIMS*GGL_MAX_VIEWPORT_DIMS }, + { EGL_MAX_PBUFFER_WIDTH, GGL_MAX_VIEWPORT_DIMS }, + { EGL_NATIVE_RENDERABLE, EGL_TRUE }, + { EGL_NATIVE_VISUAL_ID, 0 }, + { EGL_NATIVE_VISUAL_TYPE, GGL_PIXEL_FORMAT_RGBA_8888 }, + { EGL_SAMPLES, 0 }, + { EGL_SAMPLE_BUFFERS, 0 }, + { EGL_TRANSPARENT_TYPE, EGL_NONE }, + { EGL_TRANSPARENT_BLUE_VALUE, 0 }, + { EGL_TRANSPARENT_GREEN_VALUE, 0 }, + { EGL_TRANSPARENT_RED_VALUE, 0 }, + { EGL_BIND_TO_TEXTURE_RGBA, EGL_FALSE }, + { EGL_BIND_TO_TEXTURE_RGB, EGL_FALSE }, + { EGL_MIN_SWAP_INTERVAL, 1 }, + { EGL_MAX_SWAP_INTERVAL, 1 }, + { EGL_LUMINANCE_SIZE, 0 }, + { EGL_ALPHA_MASK_SIZE, 0 }, + { EGL_COLOR_BUFFER_TYPE, EGL_RGB_BUFFER }, + { EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT }, + { EGL_CONFORMANT, 0 } +}; + +// These configs can override the base attribute list +// NOTE: when adding a config here, don't forget to update eglCreate*Surface() + +// 565 configs +static config_pair_t const config_0_attribute_list[] = { + { EGL_BUFFER_SIZE, 16 }, + { EGL_ALPHA_SIZE, 0 }, + { EGL_BLUE_SIZE, 5 }, + { EGL_GREEN_SIZE, 6 }, + { EGL_RED_SIZE, 5 }, + { EGL_DEPTH_SIZE, 0 }, + { EGL_CONFIG_ID, 0 }, + { EGL_NATIVE_VISUAL_ID, GGL_PIXEL_FORMAT_RGB_565 }, + { EGL_SURFACE_TYPE, EGL_SWAP_BEHAVIOR_PRESERVED_BIT|EGL_WINDOW_BIT|EGL_PBUFFER_BIT|EGL_PIXMAP_BIT }, +}; + +static config_pair_t const config_1_attribute_list[] = { + { EGL_BUFFER_SIZE, 16 }, + { EGL_ALPHA_SIZE, 0 }, + { EGL_BLUE_SIZE, 5 }, + { EGL_GREEN_SIZE, 6 }, + { EGL_RED_SIZE, 5 }, + { EGL_DEPTH_SIZE, 16 }, + { EGL_CONFIG_ID, 1 }, + { EGL_NATIVE_VISUAL_ID, GGL_PIXEL_FORMAT_RGB_565 }, + { EGL_SURFACE_TYPE, EGL_SWAP_BEHAVIOR_PRESERVED_BIT|EGL_WINDOW_BIT|EGL_PBUFFER_BIT|EGL_PIXMAP_BIT }, +}; + +// RGB 888 configs +static config_pair_t const config_2_attribute_list[] = { + { EGL_BUFFER_SIZE, 32 }, + { EGL_ALPHA_SIZE, 0 }, + { EGL_BLUE_SIZE, 8 }, + { EGL_GREEN_SIZE, 8 }, + { EGL_RED_SIZE, 8 }, + { EGL_DEPTH_SIZE, 0 }, + { EGL_CONFIG_ID, 6 }, + { EGL_NATIVE_VISUAL_ID, GGL_PIXEL_FORMAT_RGBX_8888 }, + { EGL_SURFACE_TYPE, EGL_SWAP_BEHAVIOR_PRESERVED_BIT|EGL_WINDOW_BIT|EGL_PBUFFER_BIT|EGL_PIXMAP_BIT }, +}; + +static config_pair_t const config_3_attribute_list[] = { + { EGL_BUFFER_SIZE, 32 }, + { EGL_ALPHA_SIZE, 0 }, + { EGL_BLUE_SIZE, 8 }, + { EGL_GREEN_SIZE, 8 }, + { EGL_RED_SIZE, 8 }, + { EGL_DEPTH_SIZE, 16 }, + { EGL_CONFIG_ID, 7 }, + { EGL_NATIVE_VISUAL_ID, GGL_PIXEL_FORMAT_RGBX_8888 }, + { EGL_SURFACE_TYPE, EGL_SWAP_BEHAVIOR_PRESERVED_BIT|EGL_WINDOW_BIT|EGL_PBUFFER_BIT|EGL_PIXMAP_BIT }, +}; + +// 8888 configs +static config_pair_t const config_4_attribute_list[] = { + { EGL_BUFFER_SIZE, 32 }, + { EGL_ALPHA_SIZE, 8 }, + { EGL_BLUE_SIZE, 8 }, + { EGL_GREEN_SIZE, 8 }, + { EGL_RED_SIZE, 8 }, + { EGL_DEPTH_SIZE, 0 }, + { EGL_CONFIG_ID, 2 }, + { EGL_NATIVE_VISUAL_ID, GGL_PIXEL_FORMAT_RGBA_8888 }, + { EGL_SURFACE_TYPE, EGL_SWAP_BEHAVIOR_PRESERVED_BIT|EGL_WINDOW_BIT|EGL_PBUFFER_BIT|EGL_PIXMAP_BIT }, +}; + +static config_pair_t const config_5_attribute_list[] = { + { EGL_BUFFER_SIZE, 32 }, + { EGL_ALPHA_SIZE, 8 }, + { EGL_BLUE_SIZE, 8 }, + { EGL_GREEN_SIZE, 8 }, + { EGL_RED_SIZE, 8 }, + { EGL_DEPTH_SIZE, 16 }, + { EGL_CONFIG_ID, 3 }, + { EGL_NATIVE_VISUAL_ID, GGL_PIXEL_FORMAT_RGBA_8888 }, + { EGL_SURFACE_TYPE, EGL_SWAP_BEHAVIOR_PRESERVED_BIT|EGL_WINDOW_BIT|EGL_PBUFFER_BIT|EGL_PIXMAP_BIT }, +}; + +// A8 configs +static config_pair_t const config_6_attribute_list[] = { + { EGL_BUFFER_SIZE, 8 }, + { EGL_ALPHA_SIZE, 8 }, + { EGL_BLUE_SIZE, 0 }, + { EGL_GREEN_SIZE, 0 }, + { EGL_RED_SIZE, 0 }, + { EGL_DEPTH_SIZE, 0 }, + { EGL_CONFIG_ID, 4 }, + { EGL_NATIVE_VISUAL_ID, GGL_PIXEL_FORMAT_A_8 }, + { EGL_SURFACE_TYPE, EGL_SWAP_BEHAVIOR_PRESERVED_BIT|EGL_WINDOW_BIT|EGL_PBUFFER_BIT|EGL_PIXMAP_BIT }, +}; + +static config_pair_t const config_7_attribute_list[] = { + { EGL_BUFFER_SIZE, 8 }, + { EGL_ALPHA_SIZE, 8 }, + { EGL_BLUE_SIZE, 0 }, + { EGL_GREEN_SIZE, 0 }, + { EGL_RED_SIZE, 0 }, + { EGL_DEPTH_SIZE, 16 }, + { EGL_CONFIG_ID, 5 }, + { EGL_NATIVE_VISUAL_ID, GGL_PIXEL_FORMAT_A_8 }, + { EGL_SURFACE_TYPE, EGL_SWAP_BEHAVIOR_PRESERVED_BIT|EGL_WINDOW_BIT|EGL_PBUFFER_BIT|EGL_PIXMAP_BIT }, +}; + +static configs_t const gConfigs[] = { + { config_0_attribute_list, NELEM(config_0_attribute_list) }, + { config_1_attribute_list, NELEM(config_1_attribute_list) }, + { config_2_attribute_list, NELEM(config_2_attribute_list) }, + { config_3_attribute_list, NELEM(config_3_attribute_list) }, + { config_4_attribute_list, NELEM(config_4_attribute_list) }, + { config_5_attribute_list, NELEM(config_5_attribute_list) }, +// { config_6_attribute_list, NELEM(config_6_attribute_list) }, +// { config_7_attribute_list, NELEM(config_7_attribute_list) }, +}; + +static config_management_t const gConfigManagement[] = { + { EGL_BUFFER_SIZE, config_management_t::atLeast }, + { EGL_ALPHA_SIZE, config_management_t::atLeast }, + { EGL_BLUE_SIZE, config_management_t::atLeast }, + { EGL_GREEN_SIZE, config_management_t::atLeast }, + { EGL_RED_SIZE, config_management_t::atLeast }, + { EGL_DEPTH_SIZE, config_management_t::atLeast }, + { EGL_STENCIL_SIZE, config_management_t::atLeast }, + { EGL_CONFIG_CAVEAT, config_management_t::exact }, + { EGL_CONFIG_ID, config_management_t::exact }, + { EGL_LEVEL, config_management_t::exact }, + { EGL_MAX_PBUFFER_HEIGHT, config_management_t::ignore }, + { EGL_MAX_PBUFFER_PIXELS, config_management_t::ignore }, + { EGL_MAX_PBUFFER_WIDTH, config_management_t::ignore }, + { EGL_NATIVE_RENDERABLE, config_management_t::exact }, + { EGL_NATIVE_VISUAL_ID, config_management_t::ignore }, + { EGL_NATIVE_VISUAL_TYPE, config_management_t::exact }, + { EGL_SAMPLES, config_management_t::exact }, + { EGL_SAMPLE_BUFFERS, config_management_t::exact }, + { EGL_SURFACE_TYPE, config_management_t::mask }, + { EGL_TRANSPARENT_TYPE, config_management_t::exact }, + { EGL_TRANSPARENT_BLUE_VALUE, config_management_t::exact }, + { EGL_TRANSPARENT_GREEN_VALUE, config_management_t::exact }, + { EGL_TRANSPARENT_RED_VALUE, config_management_t::exact }, + { EGL_BIND_TO_TEXTURE_RGBA, config_management_t::exact }, + { EGL_BIND_TO_TEXTURE_RGB, config_management_t::exact }, + { EGL_MIN_SWAP_INTERVAL, config_management_t::exact }, + { EGL_MAX_SWAP_INTERVAL, config_management_t::exact }, + { EGL_LUMINANCE_SIZE, config_management_t::atLeast }, + { EGL_ALPHA_MASK_SIZE, config_management_t::atLeast }, + { EGL_COLOR_BUFFER_TYPE, config_management_t::exact }, + { EGL_RENDERABLE_TYPE, config_management_t::mask }, + { EGL_CONFORMANT, config_management_t::mask } +}; + + +static config_pair_t const config_defaults[] = { + // attributes that are not specified are simply ignored, if a particular + // one needs not be ignored, it must be specified here, eg: + // { EGL_SURFACE_TYPE, EGL_WINDOW_BIT }, +}; + +// ---------------------------------------------------------------------------- + +static status_t getConfigFormatInfo(EGLint configID, + int32_t& pixelFormat, int32_t& depthFormat) +{ + switch (configID) { + case 0: + pixelFormat = GGL_PIXEL_FORMAT_RGB_565; + depthFormat = 0; + break; + case 1: + pixelFormat = GGL_PIXEL_FORMAT_RGB_565; + depthFormat = GGL_PIXEL_FORMAT_Z_32; + break; + case 2: + pixelFormat = GGL_PIXEL_FORMAT_RGBA_8888; + depthFormat = 0; + break; + case 3: + pixelFormat = GGL_PIXEL_FORMAT_RGBA_8888; + depthFormat = GGL_PIXEL_FORMAT_Z_32; + break; + case 4: + pixelFormat = GGL_PIXEL_FORMAT_RGBA_8888; + depthFormat = 0; + break; + case 5: + pixelFormat = GGL_PIXEL_FORMAT_RGBA_8888; + depthFormat = GGL_PIXEL_FORMAT_Z_32; + break; + case 6: + pixelFormat = GGL_PIXEL_FORMAT_A_8; + depthFormat = 0; + break; + case 7: + pixelFormat = GGL_PIXEL_FORMAT_A_8; + depthFormat = GGL_PIXEL_FORMAT_Z_32; + break; + default: + return NAME_NOT_FOUND; + } + return NO_ERROR; +} + +// ---------------------------------------------------------------------------- + +template +static int binarySearch(T const sortedArray[], int first, int last, EGLint key) +{ + while (first <= last) { + int mid = (first + last) / 2; + if (key > sortedArray[mid].key) { + first = mid + 1; + } else if (key < sortedArray[mid].key) { + last = mid - 1; + } else { + return mid; + } + } + return -1; +} + +static int isAttributeMatching(int i, EGLint attr, EGLint val) +{ + // look for the attribute in all of our configs + config_pair_t const* configFound = gConfigs[i].array; + int index = binarySearch( + gConfigs[i].array, + 0, gConfigs[i].size-1, + attr); + if (index < 0) { + configFound = config_base_attribute_list; + index = binarySearch( + config_base_attribute_list, + 0, NELEM(config_base_attribute_list)-1, + attr); + } + if (index >= 0) { + // attribute found, check if this config could match + int cfgMgtIndex = binarySearch( + gConfigManagement, + 0, NELEM(gConfigManagement)-1, + attr); + if (cfgMgtIndex >= 0) { + bool match = gConfigManagement[cfgMgtIndex].match( + val, configFound[index].value); + if (match) { + // this config matches + return 1; + } + } else { + // attribute not found. this should NEVER happen. + } + } else { + // error, this attribute doesn't exist + } + return 0; +} + +static int makeCurrent(GLES2Context* gl) +{ + GLES2Context* current = (GLES2Context*)getGlThreadSpecific(); + if (gl) { + egl_context_t* c = egl_context_t::context(gl); + if (c->flags & egl_context_t::IS_CURRENT) { + if (current != gl) { + // it is an error to set a context current, if it's already + // current to another thread + return -1; + } + } else { + if (current) { + // mark the current context as not current, and flush + glFlush(); + egl_context_t::context(current)->flags &= ~egl_context_t::IS_CURRENT; + } + } + if (!(c->flags & egl_context_t::IS_CURRENT)) { + // The context is not current, make it current! + setGlThreadSpecific(gl); + c->flags |= egl_context_t::IS_CURRENT; + } + } else { + if (current) { + // mark the current context as not current, and flush + glFlush(); + egl_context_t::context(current)->flags &= ~egl_context_t::IS_CURRENT; + } + // this thread has no context attached to it + setGlThreadSpecific(0); + } + return 0; +} + +static EGLBoolean getConfigAttrib(EGLDisplay dpy, EGLConfig config, + EGLint attribute, EGLint *value) +{ + size_t numConfigs = NELEM(gConfigs); + int index = (int)config; + if (uint32_t(index) >= numConfigs) + return setError(EGL_BAD_CONFIG, EGL_FALSE); + + int attrIndex; + attrIndex = binarySearch( + gConfigs[index].array, + 0, gConfigs[index].size-1, + attribute); + if (attrIndex>=0) { + *value = gConfigs[index].array[attrIndex].value; + return EGL_TRUE; + } + + attrIndex = binarySearch( + config_base_attribute_list, + 0, NELEM(config_base_attribute_list)-1, + attribute); + if (attrIndex>=0) { + *value = config_base_attribute_list[attrIndex].value; + return EGL_TRUE; + } + return setError(EGL_BAD_ATTRIBUTE, EGL_FALSE); +} + +static EGLSurface createWindowSurface(EGLDisplay dpy, EGLConfig config, + NativeWindowType window, const EGLint *attrib_list) +{ + if (egl_display_t::is_valid(dpy) == EGL_FALSE) + return setError(EGL_BAD_DISPLAY, EGL_NO_SURFACE); + if (window == 0) + return setError(EGL_BAD_MATCH, EGL_NO_SURFACE); + + EGLint surfaceType; + if (getConfigAttrib(dpy, config, EGL_SURFACE_TYPE, &surfaceType) == EGL_FALSE) + return EGL_FALSE; + + if (!(surfaceType & EGL_WINDOW_BIT)) + return setError(EGL_BAD_MATCH, EGL_NO_SURFACE); + + if (reinterpret_cast(window)->common.magic != + ANDROID_NATIVE_WINDOW_MAGIC) { + return setError(EGL_BAD_NATIVE_WINDOW, EGL_NO_SURFACE); + } + + EGLint configID; + if (getConfigAttrib(dpy, config, EGL_CONFIG_ID, &configID) == EGL_FALSE) + return EGL_FALSE; + + int32_t depthFormat; + int32_t pixelFormat; + if (getConfigFormatInfo(configID, pixelFormat, depthFormat) != NO_ERROR) { + return setError(EGL_BAD_MATCH, EGL_NO_SURFACE); + } + + // FIXME: we don't have access to the pixelFormat here just yet. + // (it's possible that the surface is not fully initialized) + // maybe this should be done after the page-flip + //if (EGLint(info.format) != pixelFormat) + // return setError(EGL_BAD_MATCH, EGL_NO_SURFACE); + + egl_surface_t* surface; + surface = new egl_window_surface_v2_t(dpy, config, depthFormat, + reinterpret_cast(window)); + + if (!surface->initCheck()) { + // there was a problem in the ctor, the error + // flag has been set. + delete surface; + surface = 0; + } + return surface; +} + +static EGLSurface createPixmapSurface(EGLDisplay dpy, EGLConfig config, + NativePixmapType pixmap, const EGLint *attrib_list) +{ + if (egl_display_t::is_valid(dpy) == EGL_FALSE) + return setError(EGL_BAD_DISPLAY, EGL_NO_SURFACE); + if (pixmap == 0) + return setError(EGL_BAD_MATCH, EGL_NO_SURFACE); + + EGLint surfaceType; + if (getConfigAttrib(dpy, config, EGL_SURFACE_TYPE, &surfaceType) == EGL_FALSE) + return EGL_FALSE; + + if (!(surfaceType & EGL_PIXMAP_BIT)) + return setError(EGL_BAD_MATCH, EGL_NO_SURFACE); + + if (reinterpret_cast(pixmap)->version != + sizeof(egl_native_pixmap_t)) { + return setError(EGL_BAD_NATIVE_PIXMAP, EGL_NO_SURFACE); + } + + EGLint configID; + if (getConfigAttrib(dpy, config, EGL_CONFIG_ID, &configID) == EGL_FALSE) + return EGL_FALSE; + + int32_t depthFormat; + int32_t pixelFormat; + if (getConfigFormatInfo(configID, pixelFormat, depthFormat) != NO_ERROR) { + return setError(EGL_BAD_MATCH, EGL_NO_SURFACE); + } + + if (reinterpret_cast(pixmap)->format != pixelFormat) + return setError(EGL_BAD_MATCH, EGL_NO_SURFACE); + + egl_surface_t* surface = + new egl_pixmap_surface_t(dpy, config, depthFormat, + reinterpret_cast(pixmap)); + + if (!surface->initCheck()) { + // there was a problem in the ctor, the error + // flag has been set. + delete surface; + surface = 0; + } + return surface; +} + +static EGLSurface createPbufferSurface(EGLDisplay dpy, EGLConfig config, + const EGLint *attrib_list) +{ + if (egl_display_t::is_valid(dpy) == EGL_FALSE) + return setError(EGL_BAD_DISPLAY, EGL_NO_SURFACE); + + EGLint surfaceType; + if (getConfigAttrib(dpy, config, EGL_SURFACE_TYPE, &surfaceType) == EGL_FALSE) + return EGL_FALSE; + + if (!(surfaceType & EGL_PBUFFER_BIT)) + return setError(EGL_BAD_MATCH, EGL_NO_SURFACE); + + EGLint configID; + if (getConfigAttrib(dpy, config, EGL_CONFIG_ID, &configID) == EGL_FALSE) + return EGL_FALSE; + + int32_t depthFormat; + int32_t pixelFormat; + if (getConfigFormatInfo(configID, pixelFormat, depthFormat) != NO_ERROR) { + return setError(EGL_BAD_MATCH, EGL_NO_SURFACE); + } + + int32_t w = 0; + int32_t h = 0; + while (attrib_list[0]) { + if (attrib_list[0] == EGL_WIDTH) w = attrib_list[1]; + if (attrib_list[0] == EGL_HEIGHT) h = attrib_list[1]; + attrib_list+=2; + } + + egl_surface_t* surface = + new egl_pbuffer_surface_t(dpy, config, depthFormat, w, h, pixelFormat); + + if (!surface->initCheck()) { + // there was a problem in the ctor, the error + // flag has been set. + delete surface; + surface = 0; + } + return surface; +} + +// ---------------------------------------------------------------------------- +}; // namespace android +// ---------------------------------------------------------------------------- + +using namespace android; + +// ---------------------------------------------------------------------------- +// Initialization +// ---------------------------------------------------------------------------- + +EGLDisplay eglGetDisplay(NativeDisplayType display) +{ + puts("agl2:eglGetDisplay"); +#ifndef HAVE_ANDROID_OS + // this just needs to be done once + if (gGLKey == -1) { + pthread_mutex_lock(&gInitMutex); + if (gGLKey == -1) + pthread_key_create(&gGLKey, NULL); + pthread_mutex_unlock(&gInitMutex); + } +#endif + if (display == EGL_DEFAULT_DISPLAY) { + EGLDisplay dpy = (EGLDisplay)1; + egl_display_t& d = egl_display_t::get_display(dpy); + d.type = display; + return dpy; + } + return EGL_NO_DISPLAY; +} + +EGLBoolean eglInitialize(EGLDisplay dpy, EGLint *major, EGLint *minor) +{ + puts("agl2:eglInitialize"); + if (egl_display_t::is_valid(dpy) == EGL_FALSE) + return setError(EGL_BAD_DISPLAY, EGL_FALSE); + + EGLBoolean res = EGL_TRUE; + egl_display_t& d = egl_display_t::get_display(dpy); + + if (android_atomic_inc(&d.initialized) == 0) { + // initialize stuff here if needed + //pthread_mutex_lock(&gInitMutex); + //pthread_mutex_unlock(&gInitMutex); + } + + if (res == EGL_TRUE) { + if (major != NULL) *major = VERSION_MAJOR; + if (minor != NULL) *minor = VERSION_MINOR; + } + return res; +} + +EGLBoolean eglTerminate(EGLDisplay dpy) +{ + puts("agl2:eglTerminate"); + if (egl_display_t::is_valid(dpy) == EGL_FALSE) + return setError(EGL_BAD_DISPLAY, EGL_FALSE); + + EGLBoolean res = EGL_TRUE; + egl_display_t& d = egl_display_t::get_display(dpy); + if (android_atomic_dec(&d.initialized) == 1) { + // TODO: destroy all resources (surfaces, contexts, etc...) + //pthread_mutex_lock(&gInitMutex); + //pthread_mutex_unlock(&gInitMutex); + } + return res; +} + +// ---------------------------------------------------------------------------- +// configuration +// ---------------------------------------------------------------------------- + +EGLBoolean eglGetConfigs( EGLDisplay dpy, + EGLConfig *configs, + EGLint config_size, EGLint *num_config) +{ + puts("agl2:eglGetConfigs"); + if (egl_display_t::is_valid(dpy) == EGL_FALSE) + return setError(EGL_BAD_DISPLAY, EGL_FALSE); + + GLint numConfigs = NELEM(gConfigs); + if (!configs) { + *num_config = numConfigs; + return EGL_TRUE; + } + GLint i; + for (i=0 ; i attrib[0] || EGL_CONFORMANT < attrib[0]) + LOGD("eglChooseConfig invalid config attrib: 0x%.4X=%d \n", attrib[0], attrib[1]); + } + + int numAttributes = 0; + int numConfigs = NELEM(gConfigs); + uint32_t possibleMatch = (1<( + (config_pair_t const*)attrib_list, + 0, numAttributes-1, + config_defaults[j].key) < 0) { + for (int i=0 ; possibleMatch && i(eglSurface) ); + if (!surface->isValid()) + return setError(EGL_BAD_SURFACE, EGL_FALSE); + if (surface->dpy != dpy) + return setError(EGL_BAD_DISPLAY, EGL_FALSE); + if (surface->ctx) { + // FIXME: this surface is current check what the spec says + surface->disconnect(); + surface->ctx = 0; + } + delete surface; + } + return EGL_TRUE; +} + +EGLBoolean eglQuerySurface( EGLDisplay dpy, EGLSurface eglSurface, + EGLint attribute, EGLint *value) +{ + puts("agl2:eglQuerySurface"); + if (egl_display_t::is_valid(dpy) == EGL_FALSE) + return setError(EGL_BAD_DISPLAY, EGL_FALSE); + egl_surface_t* surface = static_cast(eglSurface); + if (!surface->isValid()) + return setError(EGL_BAD_SURFACE, EGL_FALSE); + if (surface->dpy != dpy) + return setError(EGL_BAD_DISPLAY, EGL_FALSE); + + EGLBoolean ret = EGL_TRUE; + switch (attribute) { + case EGL_CONFIG_ID: + ret = getConfigAttrib(dpy, surface->config, EGL_CONFIG_ID, value); + break; + case EGL_WIDTH: + *value = surface->getWidth(); + break; + case EGL_HEIGHT: + *value = surface->getHeight(); + break; + case EGL_LARGEST_PBUFFER: + // not modified for a window or pixmap surface + break; + case EGL_TEXTURE_FORMAT: + *value = EGL_NO_TEXTURE; + break; + case EGL_TEXTURE_TARGET: + *value = EGL_NO_TEXTURE; + break; + case EGL_MIPMAP_TEXTURE: + *value = EGL_FALSE; + break; + case EGL_MIPMAP_LEVEL: + *value = 0; + break; + case EGL_RENDER_BUFFER: + // TODO: return the real RENDER_BUFFER here + *value = EGL_BACK_BUFFER; + break; + case EGL_HORIZONTAL_RESOLUTION: + // pixel/mm * EGL_DISPLAY_SCALING + *value = surface->getHorizontalResolution(); + break; + case EGL_VERTICAL_RESOLUTION: + // pixel/mm * EGL_DISPLAY_SCALING + *value = surface->getVerticalResolution(); + break; + case EGL_PIXEL_ASPECT_RATIO: { + // w/h * EGL_DISPLAY_SCALING + int wr = surface->getHorizontalResolution(); + int hr = surface->getVerticalResolution(); + *value = (wr * EGL_DISPLAY_SCALING) / hr; + } + break; + case EGL_SWAP_BEHAVIOR: + *value = surface->getSwapBehavior(); + break; + default: + ret = setError(EGL_BAD_ATTRIBUTE, EGL_FALSE); + } + return ret; +} + +EGLContext eglCreateContext(EGLDisplay dpy, EGLConfig config, + EGLContext share_list, const EGLint *attrib_list) +{ + puts("agl2:eglCreateContext"); + if (egl_display_t::is_valid(dpy) == EGL_FALSE) + return setError(EGL_BAD_DISPLAY, EGL_NO_SURFACE); + + GLES2Context* gl = new GLES2Context();//ogles_init(sizeof(egl_context_t)); + if (!gl) return setError(EGL_BAD_ALLOC, EGL_NO_CONTEXT); + + //egl_context_t* c = static_cast(gl->rasterizer.base); + egl_context_t * c = &gl->egl; + c->flags = egl_context_t::NEVER_CURRENT; + c->dpy = dpy; + c->config = config; + c->read = 0; + c->draw = 0; + + c->frame = 0; + c->lastSwapTime = clock(); + c->accumulateSeconds = 0; + return (EGLContext)gl; +} + +EGLBoolean eglDestroyContext(EGLDisplay dpy, EGLContext ctx) +{ + puts("agl2:eglDestroyContext"); + if (egl_display_t::is_valid(dpy) == EGL_FALSE) + return setError(EGL_BAD_DISPLAY, EGL_FALSE); + egl_context_t* c = egl_context_t::context(ctx); + if (c->flags & egl_context_t::IS_CURRENT) + setGlThreadSpecific(0); + //ogles_uninit((GLES2Context*)ctx); + delete (GLES2Context*)ctx; + return EGL_TRUE; +} + +EGLBoolean eglMakeCurrent( EGLDisplay dpy, EGLSurface draw, + EGLSurface read, EGLContext ctx) +{ + puts("agl2:eglMakeCurrent"); + if (egl_display_t::is_valid(dpy) == EGL_FALSE) + return setError(EGL_BAD_DISPLAY, EGL_FALSE); + if (draw) { + egl_surface_t* s = (egl_surface_t*)draw; + if (!s->isValid()) + return setError(EGL_BAD_SURFACE, EGL_FALSE); + if (s->dpy != dpy) + return setError(EGL_BAD_DISPLAY, EGL_FALSE); + // TODO: check that draw is compatible with the context + } + if (read && read!=draw) { + egl_surface_t* s = (egl_surface_t*)read; + if (!s->isValid()) + return setError(EGL_BAD_SURFACE, EGL_FALSE); + if (s->dpy != dpy) + return setError(EGL_BAD_DISPLAY, EGL_FALSE); + // TODO: check that read is compatible with the context + } + + EGLContext current_ctx = EGL_NO_CONTEXT; + + if ((read == EGL_NO_SURFACE && draw == EGL_NO_SURFACE) && (ctx != EGL_NO_CONTEXT)) + return setError(EGL_BAD_MATCH, EGL_FALSE); + + if ((read != EGL_NO_SURFACE || draw != EGL_NO_SURFACE) && (ctx == EGL_NO_CONTEXT)) + return setError(EGL_BAD_MATCH, EGL_FALSE); + + if (ctx == EGL_NO_CONTEXT) { + // if we're detaching, we need the current context + current_ctx = (EGLContext)getGlThreadSpecific(); + } else { + egl_context_t* c = egl_context_t::context(ctx); + egl_surface_t* d = (egl_surface_t*)draw; + egl_surface_t* r = (egl_surface_t*)read; + if ((d && d->ctx && d->ctx != ctx) || + (r && r->ctx && r->ctx != ctx)) { + // one of the surface is bound to a context in another thread + return setError(EGL_BAD_ACCESS, EGL_FALSE); + } + } + + GLES2Context* gl = (GLES2Context*)ctx; + if (makeCurrent(gl) == 0) { + if (ctx) { + egl_context_t* c = egl_context_t::context(ctx); + egl_surface_t* d = (egl_surface_t*)draw; + egl_surface_t* r = (egl_surface_t*)read; + + if (c->draw) { + egl_surface_t* s = reinterpret_cast(c->draw); + s->disconnect(); + } + if (c->read) { + // FIXME: unlock/disconnect the read surface too + } + + c->draw = draw; + c->read = read; + + if (c->flags & egl_context_t::NEVER_CURRENT) { + c->flags &= ~egl_context_t::NEVER_CURRENT; + GLint w = 0; + GLint h = 0; + if (draw) { + w = d->getWidth(); + h = d->getHeight(); + } + gl->rasterizer.interface.Viewport(&gl->rasterizer.interface, 0, 0, w, h); + //ogles_surfaceport(gl, 0, 0); + //ogles_viewport(gl, 0, 0, w, h); + //ogles_scissor(gl, 0, 0, w, h); + } + if (d) { + if (d->connect() == EGL_FALSE) { + return EGL_FALSE; + } + d->ctx = ctx; + d->bindDrawSurface(gl); + } + if (r) { + // FIXME: lock/connect the read surface too + r->ctx = ctx; + r->bindReadSurface(gl); + } + } else { + // if surfaces were bound to the context bound to this thread + // mark then as unbound. + if (current_ctx) { + egl_context_t* c = egl_context_t::context(current_ctx); + egl_surface_t* d = (egl_surface_t*)c->draw; + egl_surface_t* r = (egl_surface_t*)c->read; + if (d) { + c->draw = 0; + d->ctx = EGL_NO_CONTEXT; + d->disconnect(); + } + if (r) { + c->read = 0; + r->ctx = EGL_NO_CONTEXT; + // FIXME: unlock/disconnect the read surface too + } + } + } + return EGL_TRUE; + } + return setError(EGL_BAD_ACCESS, EGL_FALSE); +} + +EGLContext eglGetCurrentContext(void) +{ + // eglGetCurrentContext returns the current EGL rendering context, + // as specified by eglMakeCurrent. If no context is current, + // EGL_NO_CONTEXT is returned. + return (EGLContext)getGlThreadSpecific(); +} + +EGLSurface eglGetCurrentSurface(EGLint readdraw) +{ + // eglGetCurrentSurface returns the read or draw surface attached + // to the current EGL rendering context, as specified by eglMakeCurrent. + // If no context is current, EGL_NO_SURFACE is returned. + EGLContext ctx = (EGLContext)getGlThreadSpecific(); + if (ctx == EGL_NO_CONTEXT) return EGL_NO_SURFACE; + egl_context_t* c = egl_context_t::context(ctx); + if (readdraw == EGL_READ) { + return c->read; + } else if (readdraw == EGL_DRAW) { + return c->draw; + } + return setError(EGL_BAD_ATTRIBUTE, EGL_NO_SURFACE); +} + +EGLDisplay eglGetCurrentDisplay(void) +{ + // eglGetCurrentDisplay returns the current EGL display connection + // for the current EGL rendering context, as specified by eglMakeCurrent. + // If no context is current, EGL_NO_DISPLAY is returned. + EGLContext ctx = (EGLContext)getGlThreadSpecific(); + if (ctx == EGL_NO_CONTEXT) return EGL_NO_DISPLAY; + egl_context_t* c = egl_context_t::context(ctx); + return c->dpy; +} + +EGLBoolean eglQueryContext( EGLDisplay dpy, EGLContext ctx, + EGLint attribute, EGLint *value) +{ + if (egl_display_t::is_valid(dpy) == EGL_FALSE) + return setError(EGL_BAD_DISPLAY, EGL_FALSE); + egl_context_t* c = egl_context_t::context(ctx); + switch (attribute) { + case EGL_CONFIG_ID: + // Returns the ID of the EGL frame buffer configuration with + // respect to which the context was created + return getConfigAttrib(dpy, c->config, EGL_CONFIG_ID, value); + } + return setError(EGL_BAD_ATTRIBUTE, EGL_FALSE); +} + +EGLBoolean eglWaitGL(void) +{ + return EGL_TRUE; +} + +EGLBoolean eglWaitNative(EGLint engine) +{ + return EGL_TRUE; +} + +EGLBoolean eglSwapBuffers(EGLDisplay dpy, EGLSurface draw) +{ + if (egl_display_t::is_valid(dpy) == EGL_FALSE) + return setError(EGL_BAD_DISPLAY, EGL_FALSE); + + egl_surface_t* d = static_cast(draw); + if (!d->isValid()) + return setError(EGL_BAD_SURFACE, EGL_FALSE); + if (d->dpy != dpy) + return setError(EGL_BAD_DISPLAY, EGL_FALSE); + + // post the surface + d->swapBuffers(); + + // if it's bound to a context, update the buffer + if (d->ctx != EGL_NO_CONTEXT) { + d->bindDrawSurface((GLES2Context*)d->ctx); + // if this surface is also the read surface of the context + // it is bound to, make sure to update the read buffer as well. + // The EGL spec is a little unclear about this. + egl_context_t* c = egl_context_t::context(d->ctx); + if (c->read == draw) { + d->bindReadSurface((GLES2Context*)d->ctx); + } + clock_t time = clock(); + float elapsed = (float)(time - c->lastSwapTime) / CLOCKS_PER_SEC; + c->accumulateSeconds += elapsed; + c->frame++; +// LOGD("agl2: eglSwapBuffers elapsed=%.2fms \n*", elapsed * 1000); + if (20 == c->frame) { + float avg = c->accumulateSeconds / c->frame; + LOGD("\n*\n* agl2: eglSwapBuffers %u frame avg fps=%.1f elapsed=%.2fms \n*", + c->frame, 1 / avg, avg * 1000); + c->frame = 0; + c->accumulateSeconds = 0; + } + c->lastSwapTime = time; + } + + return EGL_TRUE; +} + +EGLBoolean eglCopyBuffers( EGLDisplay dpy, EGLSurface surface, + NativePixmapType target) +{ + if (egl_display_t::is_valid(dpy) == EGL_FALSE) + return setError(EGL_BAD_DISPLAY, EGL_FALSE); + // TODO: eglCopyBuffers() + return EGL_FALSE; +} + +EGLint eglGetError(void) +{ + return getError(); +} + +const char* eglQueryString(EGLDisplay dpy, EGLint name) +{ + if (egl_display_t::is_valid(dpy) == EGL_FALSE) + return setError(EGL_BAD_DISPLAY, (const char*)0); + + switch (name) { + case EGL_VENDOR: + return gVendorString; + case EGL_VERSION: + return gVersionString; + case EGL_EXTENSIONS: + return gExtensionsString; + case EGL_CLIENT_APIS: + return gClientApiString; + } + return setError(EGL_BAD_PARAMETER, (const char *)0); +} + +// ---------------------------------------------------------------------------- +// EGL 1.1 +// ---------------------------------------------------------------------------- + +EGLBoolean eglSurfaceAttrib( + EGLDisplay dpy, EGLSurface surface, EGLint attribute, EGLint value) +{ + if (egl_display_t::is_valid(dpy) == EGL_FALSE) + return setError(EGL_BAD_DISPLAY, EGL_FALSE); + // TODO: eglSurfaceAttrib() + return setError(EGL_BAD_PARAMETER, EGL_FALSE); +} + +EGLBoolean eglBindTexImage( + EGLDisplay dpy, EGLSurface surface, EGLint buffer) +{ + if (egl_display_t::is_valid(dpy) == EGL_FALSE) + return setError(EGL_BAD_DISPLAY, EGL_FALSE); + // TODO: eglBindTexImage() + return setError(EGL_BAD_PARAMETER, EGL_FALSE); +} + +EGLBoolean eglReleaseTexImage( + EGLDisplay dpy, EGLSurface surface, EGLint buffer) +{ + if (egl_display_t::is_valid(dpy) == EGL_FALSE) + return setError(EGL_BAD_DISPLAY, EGL_FALSE); + // TODO: eglReleaseTexImage() + return setError(EGL_BAD_PARAMETER, EGL_FALSE); +} + +EGLBoolean eglSwapInterval(EGLDisplay dpy, EGLint interval) +{ + if (egl_display_t::is_valid(dpy) == EGL_FALSE) + return setError(EGL_BAD_DISPLAY, EGL_FALSE); + // TODO: eglSwapInterval() + return EGL_TRUE; +} + +// ---------------------------------------------------------------------------- +// EGL 1.2 +// ---------------------------------------------------------------------------- + +EGLBoolean eglBindAPI(EGLenum api) +{ + if (api != EGL_OPENGL_ES_API) + return setError(EGL_BAD_PARAMETER, EGL_FALSE); + return EGL_TRUE; +} + +EGLenum eglQueryAPI(void) +{ + return EGL_OPENGL_ES_API; +} + +EGLBoolean eglWaitClient(void) +{ + glFinish(); + return EGL_TRUE; +} + +EGLBoolean eglReleaseThread(void) +{ + // TODO: eglReleaseThread() + return EGL_TRUE; +} + +EGLSurface eglCreatePbufferFromClientBuffer( + EGLDisplay dpy, EGLenum buftype, EGLClientBuffer buffer, + EGLConfig config, const EGLint *attrib_list) +{ + if (egl_display_t::is_valid(dpy) == EGL_FALSE) + return setError(EGL_BAD_DISPLAY, EGL_NO_SURFACE); + // TODO: eglCreatePbufferFromClientBuffer() + return setError(EGL_BAD_PARAMETER, EGL_NO_SURFACE); +} + +// ---------------------------------------------------------------------------- +// EGL_EGLEXT_VERSION 3 +// ---------------------------------------------------------------------------- + +void (*eglGetProcAddress (const char *procname))() +{ + extention_map_t const * const map = gExtentionMap; + for (uint32_t i=0 ; icommon.magic != ANDROID_NATIVE_BUFFER_MAGIC) + return setError(EGL_BAD_PARAMETER, EGL_NO_IMAGE_KHR); + + if (native_buffer->common.version != sizeof(android_native_buffer_t)) + return setError(EGL_BAD_PARAMETER, EGL_NO_IMAGE_KHR); + + switch (native_buffer->format) { + case HAL_PIXEL_FORMAT_RGBA_8888: + case HAL_PIXEL_FORMAT_RGBX_8888: + case HAL_PIXEL_FORMAT_RGB_888: + case HAL_PIXEL_FORMAT_RGB_565: + case HAL_PIXEL_FORMAT_BGRA_8888: + case HAL_PIXEL_FORMAT_RGBA_5551: + case HAL_PIXEL_FORMAT_RGBA_4444: + break; + default: + return setError(EGL_BAD_PARAMETER, EGL_NO_IMAGE_KHR); + } + + native_buffer->common.incRef(&native_buffer->common); + return (EGLImageKHR)native_buffer; +} + +EGLBoolean eglDestroyImageKHR(EGLDisplay dpy, EGLImageKHR img) +{ + if (egl_display_t::is_valid(dpy) == EGL_FALSE) { + return setError(EGL_BAD_DISPLAY, EGL_FALSE); + } + + android_native_buffer_t* native_buffer = (android_native_buffer_t*)img; + + if (native_buffer->common.magic != ANDROID_NATIVE_BUFFER_MAGIC) + return setError(EGL_BAD_PARAMETER, EGL_FALSE); + + if (native_buffer->common.version != sizeof(android_native_buffer_t)) + return setError(EGL_BAD_PARAMETER, EGL_FALSE); + + native_buffer->common.decRef(&native_buffer->common); + + return EGL_TRUE; +} + +// ---------------------------------------------------------------------------- +// ANDROID extensions +// ---------------------------------------------------------------------------- + +EGLBoolean eglSetSwapRectangleANDROID(EGLDisplay dpy, EGLSurface draw, + EGLint left, EGLint top, EGLint width, EGLint height) +{ + if (egl_display_t::is_valid(dpy) == EGL_FALSE) + return setError(EGL_BAD_DISPLAY, EGL_FALSE); + + egl_surface_t* d = static_cast(draw); + if (!d->isValid()) + return setError(EGL_BAD_SURFACE, EGL_FALSE); + if (d->dpy != dpy) + return setError(EGL_BAD_DISPLAY, EGL_FALSE); + + // post the surface + d->setSwapRectangle(left, top, width, height); + + return EGL_TRUE; +} diff --git a/opengl/libagl2/src/get.cpp b/opengl/libagl2/src/get.cpp new file mode 100644 index 0000000..13c28ce --- /dev/null +++ b/opengl/libagl2/src/get.cpp @@ -0,0 +1,79 @@ +#include "gles2context.h" + +static char const * const gVendorString = "Android"; +static char const * const gRendererString = "Android PixelFlinger2 0.0"; +static char const * const gVersionString = "OpenGL ES 2.0"; +static char const * const gExtensionsString = +// "GL_OES_byte_coordinates " // OK +// "GL_OES_fixed_point " // OK +// "GL_OES_single_precision " // OK +// "GL_OES_read_format " // OK +// "GL_OES_compressed_paletted_texture " // OK +// "GL_OES_draw_texture " // OK +// "GL_OES_matrix_get " // OK +// "GL_OES_query_matrix " // OK +// // "GL_OES_point_size_array " // TODO +// // "GL_OES_point_sprite " // TODO +// "GL_OES_EGL_image " // OK +//#ifdef GL_OES_compressed_ETC1_RGB8_texture +// "GL_OES_compressed_ETC1_RGB8_texture " // OK +//#endif +// "GL_ARB_texture_compression " // OK +// "GL_ARB_texture_non_power_of_two " // OK +// "GL_ANDROID_user_clip_plane " // OK +// "GL_ANDROID_vertex_buffer_object " // OK +// "GL_ANDROID_generate_mipmap " // OK + "" + ; + +void glGetIntegerv(GLenum pname, GLint* params) +{ + switch (pname) { + case GL_MAX_TEXTURE_SIZE : + *params = 4096; // limit is in precision of texcoord calculation, which uses 16.16 + break; + case GL_MAX_VERTEX_ATTRIBS: + *params = GGL_MAXVERTEXATTRIBS; + break; + case GL_MAX_VERTEX_UNIFORM_VECTORS: + *params = GGL_MAXVERTEXUNIFORMVECTORS; + break; + case GL_MAX_VARYING_VECTORS: + *params = GGL_MAXVARYINGVECTORS; + break; + case GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS: + *params = GGL_MAXCOMBINEDTEXTUREIMAGEUNITS; + break; + case GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS: + *params = GGL_MAXVERTEXTEXTUREIMAGEUNITS; + break; + case GL_MAX_TEXTURE_IMAGE_UNITS: + *params = GGL_MAXTEXTUREIMAGEUNITS; + break; + case GL_MAX_FRAGMENT_UNIFORM_VECTORS: + *params = GGL_MAXFRAGMENTUNIFORMVECTORS; + break; + case GL_ALIASED_LINE_WIDTH_RANGE: + *params = 1; // TODO: not implemented + break; + default: + LOGD("agl2: glGetIntegerv 0x%.4X", pname); + assert(0); + } +} + +const GLubyte* glGetString(GLenum name) +{ + switch (name) { + case GL_VENDOR: + return (const GLubyte*)gVendorString; + case GL_RENDERER: + return (const GLubyte*)gRendererString; + case GL_VERSION: + return (const GLubyte*)gVersionString; + case GL_EXTENSIONS: + return (const GLubyte*)gExtensionsString; + } + assert(0); //(c, GL_INVALID_ENUM); + return 0; +} diff --git a/opengl/libagl2/src/gles2context.h b/opengl/libagl2/src/gles2context.h new file mode 100644 index 0000000..cec0340 --- /dev/null +++ b/opengl/libagl2/src/gles2context.h @@ -0,0 +1,166 @@ +#define _SIZE_T_DEFINED_ +typedef unsigned int size_t; + +#include +#include + +#include +#include +#include +#include + +#include +#include + +#include + +#include + +#ifdef __arm__ +#ifndef __location__ +#define __HIERALLOC_STRING_0__(s) #s +#define __HIERALLOC_STRING_1__(s) __HIERALLOC_STRING_0__(s) +#define __HIERALLOC_STRING_2__ __HIERALLOC_STRING_1__(__LINE__) +#define __location__ __FILE__ ":" __HIERALLOC_STRING_2__ +#endif +#undef assert +#define assert(EXPR) { do { if (!(EXPR)) {LOGD("\n*\n*\n*\n* assert fail: '"#EXPR"' at "__location__"\n*\n*\n*\n*"); exit(EXIT_FAILURE); } } while (false); } +//#define printf LOGD +#else // #ifdef __arm__ +//#define LOGD printf +#endif // #ifdef __arm__ + + +#include +#include + +#include + +typedef uint8_t GGLubyte; // ub + +#define ggl_likely(x) __builtin_expect(!!(x), 1) +#define ggl_unlikely(x) __builtin_expect(!!(x), 0) + +#undef NELEM +#define NELEM(x) (sizeof(x)/sizeof(*(x))) + +template +inline T max(T a, T b) +{ + return a +inline T min(T a, T b) +{ + return a +// We have a dedicated TLS slot in bionic +inline void setGlThreadSpecific(GLES2Context *value) +{ + ((uint32_t *)__get_tls())[TLS_SLOT_OPENGL] = (uint32_t)value; +} +inline GLES2Context* getGlThreadSpecific() +{ + return (GLES2Context *)(((unsigned *)__get_tls())[TLS_SLOT_OPENGL]); +} +#else +extern pthread_key_t gGLKey; +inline void setGlThreadSpecific(GLES2Context *value) +{ + pthread_setspecific(gGLKey, value); +} +inline GLES2Context* getGlThreadSpecific() +{ + return static_cast(pthread_getspecific(gGLKey)); +} +#endif + +struct VBO { + unsigned size; + GLenum usage; + void * data; +}; + +struct GLES2Context { + GGLContext rasterizer; + egl_context_t egl; + GGLInterface * iface; // shortcut to &rasterizer.interface + + struct VertexState { + struct VertAttribPointer { + unsigned size; // number of values per vertex + GLenum type; // data type + unsigned stride; // bytes + const void * ptr; +bool normalized : + 1; +bool enabled : + 1; + } attribs [GGL_MAXVERTEXATTRIBS]; + + VBO * vbo, * indices; + std::map vbos; + GLuint free; + + Vector4 defaultAttribs [GGL_MAXVERTEXATTRIBS]; + } vert; + + struct TextureState { + GGLTexture * tmus[GGL_MAXCOMBINEDTEXTUREIMAGEUNITS]; + int sampler2tmu[GGL_MAXCOMBINEDTEXTUREIMAGEUNITS]; // sampler2tmu[sampler] is index of tmu, -1 means not used + unsigned active; + std::map textures; + GLuint free; // first possible free name + GGLTexture * tex2D, * texCube; // default textures + unsigned unpack; + + void UpdateSampler(GGLInterface * iface, unsigned tmu); + } tex; + + GLES2Context(); + void InitializeTextures(); + void InitializeVertices(); + + ~GLES2Context(); + void UninitializeTextures(); + void UninitializeVertices(); + + static inline GLES2Context* get() { + return getGlThreadSpecific(); + } +}; + +inline egl_context_t* egl_context_t::context(EGLContext ctx) +{ + GLES2Context* const gl = static_cast(ctx); + return static_cast(&gl->egl); +} + +#define GLES2_GET_CONTEXT(ctx) GLES2Context * ctx = GLES2Context::get(); \ + /*puts(__FUNCTION__);*/ +#define GLES2_GET_CONST_CONTEXT(ctx) GLES2Context * ctx = GLES2Context::get(); \ + /*puts(__FUNCTION__);*/ diff --git a/opengl/libagl2/src/shader.cpp b/opengl/libagl2/src/shader.cpp new file mode 100644 index 0000000..076e388 --- /dev/null +++ b/opengl/libagl2/src/shader.cpp @@ -0,0 +1,191 @@ +#include "gles2context.h" + +//#undef LOGD +//#define LOGD(...) + +static inline GLuint s2n(gl_shader * s) +{ + return (GLuint)s ^ 0xaf3c532d; +} + +static inline gl_shader * n2s(GLuint n) +{ + return (gl_shader *)(n ^ 0xaf3c532d); +} + +static inline GLuint p2n(gl_shader_program * p) +{ + return (GLuint)p ^ 0x04dc18f9; +} + +static inline gl_shader_program * n2p(GLuint n) +{ + return (gl_shader_program *)(n ^ 0x04dc18f9); +} + +void glAttachShader(GLuint program, GLuint shader) +{ + GLES2_GET_CONST_CONTEXT(ctx); + ctx->iface->ShaderAttach(ctx->iface, n2p(program), n2s(shader)); +} + +void glBindAttribLocation(GLuint program, GLuint index, const GLchar* name) +{ + GLES2_GET_CONST_CONTEXT(ctx); + ctx->iface->ShaderAttributeBind(n2p(program), index, name); +// assert(0); +} + +GLuint glCreateShader(GLenum type) +{ + GLES2_GET_CONST_CONTEXT(ctx); + return s2n(ctx->iface->ShaderCreate(ctx->iface, type)); +} + +GLuint glCreateProgram(void) +{ + GLES2_GET_CONST_CONTEXT(ctx); + return p2n(ctx->iface->ShaderProgramCreate(ctx->iface)); +} + +void glCompileShader(GLuint shader) +{ + GLES2_GET_CONST_CONTEXT(ctx); + ctx->iface->ShaderCompile(ctx->iface, n2s(shader), NULL, NULL); +} + +void glDeleteProgram(GLuint program) +{ + GLES2_GET_CONST_CONTEXT(ctx); + ctx->iface->ShaderProgramDelete(ctx->iface, n2p(program)); +} + +void glDeleteShader(GLuint shader) +{ + GLES2_GET_CONST_CONTEXT(ctx); + ctx->iface->ShaderDelete(ctx->iface, n2s(shader)); +} + +void glDetachShader(GLuint program, GLuint shader) +{ + GLES2_GET_CONST_CONTEXT(ctx); + ctx->iface->ShaderDetach(ctx->iface, n2p(program), n2s(shader)); +} + +GLint glGetAttribLocation(GLuint program, const GLchar* name) +{ + GLES2_GET_CONST_CONTEXT(ctx); + GLint location = ctx->iface->ShaderAttributeLocation(n2p(program), name); +// LOGD("\n*\n*\n* agl2: glGetAttribLocation program=%u name=%s location=%d \n*\n*", +// program, name, location); + return location; +} + +void glGetProgramiv(GLuint program, GLenum pname, GLint* params) +{ + GLES2_GET_CONST_CONTEXT(ctx); + ctx->iface->ShaderProgramGetiv(n2p(program), pname, params); + LOGD("agl2: glGetProgramiv 0x%.4X=%d \n", pname, *params); +} + +void glGetProgramInfoLog(GLuint program, GLsizei bufsize, GLsizei* length, GLchar* infolog) +{ + GLES2_GET_CONST_CONTEXT(ctx); + ctx->iface->ShaderProgramGetInfoLog(n2p(program), bufsize, length, infolog); +} + +void glGetShaderiv(GLuint shader, GLenum pname, GLint* params) +{ + GLES2_GET_CONST_CONTEXT(ctx); + ctx->iface->ShaderGetiv(n2s(shader), pname, params); + LOGD("agl2: glGetShaderiv 0x%.4X=%d \n", pname, *params); +} + +void glGetShaderInfoLog(GLuint shader, GLsizei bufsize, GLsizei* length, GLchar* infolog) +{ + GLES2_GET_CONST_CONTEXT(ctx); + ctx->iface->ShaderGetInfoLog(n2s(shader), bufsize, length, infolog); +} + +int glGetUniformLocation(GLuint program, const GLchar* name) +{ + GLES2_GET_CONST_CONTEXT(ctx); + return ctx->iface->ShaderUniformLocation(n2p(program), name); +} + +void glLinkProgram(GLuint program) +{ + GLES2_GET_CONST_CONTEXT(ctx); + GLboolean linked = ctx->iface->ShaderProgramLink(n2p(program), NULL); + assert(linked); +} + +void glShaderSource(GLuint shader, GLsizei count, const GLchar** string, const GLint* length) +{ + GLES2_GET_CONST_CONTEXT(ctx); + ctx->iface->ShaderSource(n2s(shader), count, string, length); +} + +void glUniform1f(GLint location, GLfloat x) +{ + GLES2_GET_CONST_CONTEXT(ctx); + int sampler = ctx->iface->ShaderUniform(ctx->rasterizer.CurrentProgram, location, 1, &x, GL_FLOAT); + assert(0 > sampler); // should be assigning to sampler +} + +void glUniform1i(GLint location, GLint x) +{ + GLES2_GET_CONST_CONTEXT(ctx); + const float params[1] = {x}; + int sampler = ctx->iface->ShaderUniform(ctx->rasterizer.CurrentProgram, location, 1, params, GL_INT); + if (0 <= sampler) { +// LOGD("\n*\n* agl2: glUniform1i updated sampler=%d tmu=%d location=%d\n*", sampler, x, location); + assert(0 <= x && GGL_MAXCOMBINEDTEXTUREIMAGEUNITS > x); +// LOGD("tmu%u: format=0x%.2X w=%u h=%u levels=%p", x, ctx->tex.tmus[x]->format, +// ctx->tex.tmus[x]->width, ctx->tex.tmus[x]->height, ctx->tex.tmus[x]->format); + ctx->tex.sampler2tmu[sampler] = x; + ctx->tex.UpdateSampler(ctx->iface, x); + } +} + +void glUniform2f(GLint location, GLfloat x, GLfloat y) +{ + GLES2_GET_CONST_CONTEXT(ctx); + const float params[4] = {x, y}; + ctx->iface->ShaderUniform(ctx->rasterizer.CurrentProgram, location, 1, params, GL_FLOAT_VEC2); +} + +void glUniform4f(GLint location, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + GLES2_GET_CONST_CONTEXT(ctx); + const float params[4] = {x, y, z, w}; +// LOGD("agl2: glUniform4f location=%d %f,%f,%f,%f", location, x, y, z, w); + ctx->iface->ShaderUniform(ctx->rasterizer.CurrentProgram, location, 1, params, GL_FLOAT_VEC4); +} + +void glUniformMatrix4fv(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) +{ + GLES2_GET_CONST_CONTEXT(ctx); +// const gl_shader_program * program = ctx->rasterizer.CurrentProgram; +// if (strstr(program->Shaders[MESA_SHADER_FRAGMENT]->Source, ").a;")) { +// LOGD("agl2: glUniformMatrix4fv location=%d count=%d transpose=%d", location, count, transpose); +// for (unsigned i = 0; i < 4; i++) +// LOGD("agl2: glUniformMatrix4fv %.2f \t %.2f \t %.2f \t %.2f", value[i * 4 + 0], +// value[i * 4 + 1], value[i * 4 + 2], value[i * 4 + 3]); +// } + ctx->iface->ShaderUniformMatrix(ctx->rasterizer.CurrentProgram, 4, 4, location, count, transpose, value); +// while (true) +// ; +// assert(0); +} + +void glUseProgram(GLuint program) +{ + GLES2_GET_CONST_CONTEXT(ctx); +// LOGD("\n*\n*\n* agl2: glUseProgram %d \n*\n*\n*", program); + ctx->iface->ShaderUse(ctx->iface, n2p(program)); + ctx->iface->ShaderUniformGetSamplers(n2p(program), ctx->tex.sampler2tmu); + for (unsigned i = 0; i < GGL_MAXCOMBINEDTEXTUREIMAGEUNITS; i++) + if (0 <= ctx->tex.sampler2tmu[i]) + ctx->iface->SetSampler(ctx->iface, i, ctx->tex.tmus[ctx->tex.sampler2tmu[i]]); +} diff --git a/opengl/libagl2/src/state.cpp b/opengl/libagl2/src/state.cpp new file mode 100644 index 0000000..22e73fa --- /dev/null +++ b/opengl/libagl2/src/state.cpp @@ -0,0 +1,129 @@ +#include "gles2context.h" + +GLES2Context::GLES2Context() +{ + memset(this, 0, sizeof *this); + + assert((void *)&rasterizer == &rasterizer.interface); + InitializeGGLState(&rasterizer.interface); + iface = &rasterizer.interface; + printf("gl->rasterizer.PickScanLine(%p) = %p \n", &rasterizer.PickScanLine, rasterizer.PickScanLine); + assert(rasterizer.PickRaster); + assert(rasterizer.PickScanLine); + + InitializeTextures(); + InitializeVertices(); +} + +GLES2Context::~GLES2Context() +{ + UninitializeTextures(); + UninitializeVertices(); + UninitializeGGLState(&rasterizer.interface); +} + +void glBlendColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) +{ + GLES2_GET_CONST_CONTEXT(ctx); + ctx->iface->BlendColor(ctx->iface, red, green, blue, alpha); +} + +void glBlendEquation( GLenum mode ) +{ + GLES2_GET_CONST_CONTEXT(ctx); + ctx->iface->BlendEquationSeparate(ctx->iface, mode, mode); +} + +void glBlendEquationSeparate(GLenum modeRGB, GLenum modeAlpha) +{ + GLES2_GET_CONST_CONTEXT(ctx); + ctx->iface->BlendEquationSeparate(ctx->iface, modeRGB, modeAlpha); +} + +void glBlendFunc(GLenum sfactor, GLenum dfactor) +{ + GLES2_GET_CONST_CONTEXT(ctx); + ctx->iface->BlendFuncSeparate(ctx->iface, sfactor, dfactor, sfactor, dfactor); +} + +void glBlendFuncSeparate(GLenum srcRGB, GLenum dstRGB, GLenum srcAlpha, GLenum dstAlpha) +{ + GLES2_GET_CONST_CONTEXT(ctx); + ctx->iface->BlendFuncSeparate(ctx->iface, srcRGB, dstRGB, srcAlpha, dstAlpha); +} + +void glClear(GLbitfield mask) +{ + GLES2_GET_CONST_CONTEXT(ctx); + ctx->iface->Clear(ctx->iface, mask); +} + +void glClearColor(GLclampf red, GLclampf green, GLclampf blue, GLclampf alpha) +{ + GLES2_GET_CONST_CONTEXT(ctx); + ctx->iface->ClearColor(ctx->iface, red, green, blue, alpha); +} + +void glClearDepthf(GLclampf depth) +{ + GLES2_GET_CONST_CONTEXT(ctx); + ctx->iface->ClearDepthf(ctx->iface, depth); +} + +void glClearStencil(GLint s) +{ + GLES2_GET_CONST_CONTEXT(ctx); + ctx->iface->ClearStencil(ctx->iface, s); +} + +void glCullFace(GLenum mode) +{ + GLES2_GET_CONST_CONTEXT(ctx); + ctx->iface->CullFace(ctx->iface, mode); +} + +void glDisable(GLenum cap) +{ + GLES2_GET_CONST_CONTEXT(ctx); + ctx->iface->EnableDisable(ctx->iface, cap, false); +} + +void glEnable(GLenum cap) +{ + GLES2_GET_CONST_CONTEXT(ctx); + ctx->iface->EnableDisable(ctx->iface, cap, true); +} + +void glFinish(void) +{ + // do nothing +} + +void glFrontFace(GLenum mode) +{ + GLES2_GET_CONST_CONTEXT(ctx); + ctx->iface->FrontFace(ctx->iface, mode); +} + +void glFlush(void) +{ + // do nothing +} + +void glHint(GLenum target, GLenum mode) +{ + // do nothing +} + +void glScissor(GLint x, GLint y, GLsizei width, GLsizei height) +{ +// LOGD("agl2: glScissor not implemented x=%d y=%d width=%d height=%d", x, y, width, height); + //CALL_GL_API(glScissor, x, y, width, height); +} + +void glViewport(GLint x, GLint y, GLsizei width, GLsizei height) +{ + GLES2_GET_CONST_CONTEXT(ctx); +// LOGD("agl2: glViewport x=%d y=%d width=%d height=%d", x, y, width, height); + ctx->iface->Viewport(ctx->iface, x, y, width, height); +} diff --git a/opengl/libagl2/src/texture.cpp b/opengl/libagl2/src/texture.cpp new file mode 100644 index 0000000..4de1f16 --- /dev/null +++ b/opengl/libagl2/src/texture.cpp @@ -0,0 +1,534 @@ +#include "gles2context.h" + +//#undef LOGD +//#define LOGD(...) + +#define API_ENTRY +#define CALL_GL_API(NAME,...) LOGD("?"#NAME); assert(0); +#define CALL_GL_API_RETURN(NAME,...) LOGD("?"#NAME); assert(0); return 0; + +static inline GGLTexture * AllocTexture() +{ + GGLTexture * tex = (GGLTexture *)calloc(1, sizeof(GGLTexture)); + tex->minFilter = GGLTexture::GGL_LINEAR; // should be NEAREST_ MIPMAP_LINEAR + tex->magFilter = GGLTexture::GGL_LINEAR; + return tex; +} + +void GLES2Context::InitializeTextures() +{ + tex.textures = std::map(); // the entire struct has been zeroed in constructor + tex.tex2D = AllocTexture(); + tex.textures[GL_TEXTURE_2D] = tex.tex2D; + tex.texCube = AllocTexture(); + tex.textures[GL_TEXTURE_CUBE_MAP] = tex.texCube; + for (unsigned i = 0; i < GGL_MAXCOMBINEDTEXTUREIMAGEUNITS; i++) { + tex.tmus[i] = NULL; + tex.sampler2tmu[i] = NULL; + } + + tex.active = 0; + + tex.free = max(GL_TEXTURE_2D, GL_TEXTURE_CUBE_MAP) + 1; + + tex.tex2D->format = GGL_PIXEL_FORMAT_RGBA_8888; + tex.tex2D->type = GL_TEXTURE_2D; + tex.tex2D->levelCount = 1; + tex.tex2D->wrapS = tex.tex2D->wrapT = GGLTexture::GGL_REPEAT; + tex.tex2D->minFilter = tex.tex2D->magFilter = GGLTexture::GGL_NEAREST; + tex.tex2D->width = tex.tex2D->height = 1; + tex.tex2D->levels = malloc(4); + *(unsigned *)tex.tex2D->levels = 0xff000000; + + + tex.texCube->format = GGL_PIXEL_FORMAT_RGBA_8888; + tex.texCube->type = GL_TEXTURE_CUBE_MAP; + tex.texCube->levelCount = 1; + tex.texCube->wrapS = tex.texCube->wrapT = GGLTexture::GGL_REPEAT; + tex.texCube->minFilter = tex.texCube->magFilter = GGLTexture::GGL_NEAREST; + tex.texCube->width = tex.texCube->height = 1; + tex.texCube->levels = malloc(4 * 6); + static unsigned texels [6] = {0xff0000ff, 0xff00ff00, 0xffff0000, + 0xff00ffff, 0xffffff00, 0xffff00ff + }; + memcpy(tex.texCube->levels, texels, sizeof texels); + + //texture.levelCount = GenerateMipmaps(texture.levels, texture.width, texture.height); + + // static unsigned texels [6] = {0xff0000ff, 0xff00ff00, 0xffff0000, + // 0xff00ffff, 0xffffff00, 0xffff00ff}; + // memcpy(texture.levels[0], texels, sizeof texels); + // texture.format = GGL_PIXEL_FORMAT_RGBA_8888; + // texture.width = texture.height = 1; + //texture.height /= 6; + //texture.type = GL_TEXTURE_CUBE_MAP; + + tex.unpack = 4; +} + +void GLES2Context::TextureState::UpdateSampler(GGLInterface * iface, unsigned tmu) +{ + for (unsigned i = 0; i < GGL_MAXCOMBINEDTEXTUREIMAGEUNITS; i++) + if (tmu == sampler2tmu[i]) + iface->SetSampler(iface, i, tmus[tmu]); +} + +void GLES2Context::UninitializeTextures() +{ + for (std::map::iterator it = tex.textures.begin(); it != tex.textures.end(); it++) { + if (!it->second) + continue; + free(it->second->levels); + free(it->second); + } +} + +static inline void GetFormatAndBytesPerPixel(const GLenum format, unsigned * bytesPerPixel, + GGLPixelFormat * texFormat) +{ + switch (format) { + case GL_ALPHA: + *texFormat = GGL_PIXEL_FORMAT_A_8; + *bytesPerPixel = 1; + break; + case GL_LUMINANCE: + *texFormat = GGL_PIXEL_FORMAT_L_8; + *bytesPerPixel = 1; + break; + case GL_LUMINANCE_ALPHA: + *texFormat = GGL_PIXEL_FORMAT_LA_88; + *bytesPerPixel = 2; + break; + case GL_RGB: + *texFormat = GGL_PIXEL_FORMAT_RGB_888; + *bytesPerPixel = 3; + break; + case GL_RGBA: + *texFormat = GGL_PIXEL_FORMAT_RGBA_8888; + *bytesPerPixel = 4; + break; + + // internal formats to avoid conversion + case GL_UNSIGNED_SHORT_5_6_5: + *texFormat = GGL_PIXEL_FORMAT_RGB_565; + *bytesPerPixel = 2; + break; + + default: + assert(0); + return; + } +} + +static inline void CopyTexture(char * dst, const char * src, const unsigned bytesPerPixel, + const unsigned sx, const unsigned sy, const unsigned sw, + const unsigned dx, const unsigned dy, const unsigned dw, + const unsigned w, const unsigned h) +{ + const unsigned bpp = bytesPerPixel; + if (dw == sw && dw == w && sx == 0 && dx == 0) + memcpy(dst + dy * dw * bpp, src + sy * sw * bpp, w * h * bpp); + else + for (unsigned y = 0; y < h; y++) + memcpy(dst + ((dy + y) * dw + dx) * bpp, src + ((sy + y) * sw + sx) * bpp, w * bpp); +} + +void glActiveTexture(GLenum texture) +{ + GLES2_GET_CONST_CONTEXT(ctx); + unsigned index = texture - GL_TEXTURE0; + assert(NELEM(ctx->tex.tmus) > index); +// LOGD("agl2: glActiveTexture %u", index); + ctx->tex.active = index; +} + +void glBindTexture(GLenum target, GLuint texture) +{ + GLES2_GET_CONST_CONTEXT(ctx); +// LOGD("agl2: glBindTexture target=0x%.4X texture=%u active=%u", target, texture, ctx->tex.active); + std::map::iterator it = ctx->tex.textures.find(texture); + GGLTexture * tex = NULL; + if (it != ctx->tex.textures.end()) { + tex = it->second; + if (!tex) { + tex = AllocTexture(); + tex->type = target; + it->second = tex; +// LOGD("agl2: glBindTexture allocTexture"); + } +// else +// LOGD("agl2: glBindTexture bind existing texture"); + assert(target == tex->type); + } else if (0 == texture) { + if (GL_TEXTURE_2D == target) + { + tex = ctx->tex.tex2D; +// LOGD("agl2: glBindTexture bind default tex2D"); + } + else if (GL_TEXTURE_CUBE_MAP == target) + { + tex = ctx->tex.texCube; +// LOGD("agl2: glBindTexture bind default texCube"); + } + else + assert(0); + } else { + if (texture <= ctx->tex.free) + ctx->tex.free = texture + 1; + tex = AllocTexture(); + tex->type = target; + ctx->tex.textures[texture] = tex; +// LOGD("agl2: glBindTexture new texture=%u", texture); + } + ctx->tex.tmus[ctx->tex.active] = tex; +// LOGD("agl2: glBindTexture format=0x%.2X w=%u h=%u levels=%p", tex->format, +// tex->width, tex->height, tex->levels); + ctx->tex.UpdateSampler(ctx->iface, ctx->tex.active); +} + +void API_ENTRY(glCompressedTexImage2D)(GLenum target, GLint level, GLenum internalformat, GLsizei width, GLsizei height, GLint border, GLsizei imageSize, const GLvoid* data) +{ + CALL_GL_API(glCompressedTexImage2D, target, level, internalformat, width, height, border, imageSize, data); +} + +void API_ENTRY(glCompressedTexSubImage2D)(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLsizei imageSize, const GLvoid* data) +{ + CALL_GL_API(glCompressedTexSubImage2D, target, level, xoffset, yoffset, width, height, format, imageSize, data); +} + +void glCopyTexImage2D(GLenum target, GLint level, GLenum internalformat, + GLint x, GLint y, GLsizei width, GLsizei height, GLint border) +{ + GLES2_GET_CONST_CONTEXT(ctx); +// LOGD("agl2: glCopyTexImage2D target=0x%.4X internalformat=0x%.4X", target, internalformat); +// LOGD("x=%d y=%d width=%d height=%d border=%d level=%d ", x, y, width, height, border, level); + assert(0 == border); + assert(0 == level); + unsigned bytesPerPixel = 0; + GGLPixelFormat texFormat = GGL_PIXEL_FORMAT_UNKNOWN; + GetFormatAndBytesPerPixel(internalformat, &bytesPerPixel, &texFormat); + + assert(texFormat == ctx->rasterizer.frameSurface.format); +// LOGD("texFormat=0x%.2X bytesPerPixel=%d \n", texFormat, bytesPerPixel); + unsigned offset = 0, size = width * height * bytesPerPixel, totalSize = size; + + assert(ctx->tex.tmus[ctx->tex.active]); + assert(y + height <= ctx->rasterizer.frameSurface.height); + assert(x + width <= ctx->rasterizer.frameSurface.width); + GGLTexture & tex = *ctx->tex.tmus[ctx->tex.active]; + tex.width = width; + tex.height = height; + tex.levelCount = 1; + tex.format = texFormat; + switch (target) { + case GL_TEXTURE_2D: + tex.levels = realloc(tex.levels, totalSize); + CopyTexture((char *)tex.levels, (const char *)ctx->rasterizer.frameSurface.data, bytesPerPixel, + x, y, ctx->rasterizer.frameSurface.width, 0, 0, width, width, height); + break; + default: + assert(0); + return; + } + ctx->tex.UpdateSampler(ctx->iface, ctx->tex.active); +} + +void glCopyTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLint x, GLint y, GLsizei width, GLsizei height) +{ + // x, y are src offset + // xoffset and yoffset are dst offset + GLES2_GET_CONST_CONTEXT(ctx); +// LOGD("agl2: glCopyTexSubImage2D target=0x%.4X level=%d", target, level); +// LOGD("xoffset=%d yoffset=%d x=%d y=%d width=%d height=%d", xoffset, yoffset, x, y, width, height); + assert(0 == level); + + unsigned bytesPerPixel = 4; + unsigned offset = 0, size = width * height * bytesPerPixel, totalSize = size; + + assert(ctx->tex.tmus[ctx->tex.active]); + GGLTexture & tex = *ctx->tex.tmus[ctx->tex.active]; + + assert(tex.format == ctx->rasterizer.frameSurface.format); + assert(GGL_PIXEL_FORMAT_RGBA_8888 == tex.format); + + const unsigned srcWidth = ctx->rasterizer.frameSurface.width; + const unsigned srcHeight = ctx->rasterizer.frameSurface.height; + + assert(x >= 0 && y >= 0); + assert(xoffset >= 0 && yoffset >= 0); + assert(x + width <= srcWidth); + assert(y + height <= srcHeight); + assert(xoffset + width <= tex.width); + assert(yoffset + height <= tex.height); + + switch (target) { + case GL_TEXTURE_2D: + CopyTexture((char *)tex.levels, (const char *)ctx->rasterizer.frameSurface.data, bytesPerPixel, + x, y, srcWidth, xoffset, yoffset, tex.width, width, height); + break; + default: + assert(0); + return; + } + ctx->tex.UpdateSampler(ctx->iface, ctx->tex.active); +} + +void glDeleteTextures(GLsizei n, const GLuint* textures) +{ + GLES2_GET_CONST_CONTEXT(ctx); + for (unsigned i = 0; i < n; i++) { + std::map::iterator it = ctx->tex.textures.find(textures[i]); + if (it == ctx->tex.textures.end()) + continue; + ctx->tex.free = min(ctx->tex.free, textures[i]); + for (unsigned i = 0; i < GGL_MAXCOMBINEDTEXTUREIMAGEUNITS; i++) + if (ctx->tex.tmus[i] == it->second) { + if (GL_TEXTURE_2D == it->second->type) + ctx->tex.tmus[i] = ctx->tex.tex2D; + else if (GL_TEXTURE_CUBE_MAP == it->second->type) + ctx->tex.tmus[i] = ctx->tex.texCube; + else + assert(0); + ctx->tex.UpdateSampler(ctx->iface, i); + } + if (it->second) { + free(it->second->levels); + free(it->second); + } + ctx->tex.textures.erase(it); + } +} + +void glGenTextures(GLsizei n, GLuint* textures) +{ + GLES2_GET_CONST_CONTEXT(ctx); + for (unsigned i = 0; i < n; i++) { + textures[i] = 0; + for (ctx->tex.free; ctx->tex.free < 0xffffffffu; ctx->tex.free++) + if (ctx->tex.textures.find(ctx->tex.free) == ctx->tex.textures.end()) { + ctx->tex.textures[ctx->tex.free] = NULL; + textures[i] = ctx->tex.free; + ctx->tex.free++; + break; + } + assert(textures[i]); + } +} + +void API_ENTRY(glGetTexParameterfv)(GLenum target, GLenum pname, GLfloat* params) +{ + CALL_GL_API(glGetTexParameterfv, target, pname, params); +} +void API_ENTRY(glGetTexParameteriv)(GLenum target, GLenum pname, GLint* params) +{ + CALL_GL_API(glGetTexParameteriv, target, pname, params); +} + +GLboolean glIsTexture(GLuint texture) +{ + GLES2_GET_CONST_CONTEXT(ctx); + if (ctx->tex.textures.find(texture) == ctx->tex.textures.end()) + return GL_FALSE; + else + return GL_TRUE; +} + +void glPixelStorei(GLenum pname, GLint param) +{ + GLES2_GET_CONST_CONTEXT(ctx); + assert(GL_UNPACK_ALIGNMENT == pname); + assert(1 == param || 2 == param || 4 == param || 8 == param); +// LOGD("\n*\n* agl2: glPixelStorei not implemented pname=0x%.4X param=%d \n*", pname, param); + ctx->tex.unpack = param; +// CALL_GL_API(glPixelStorei, pname, param); +} +void glTexImage2D(GLenum target, GLint level, GLint internalformat, GLsizei width, + GLsizei height, GLint border, GLenum format, GLenum type, const GLvoid* pixels) +{ + GLES2_GET_CONST_CONTEXT(ctx); +// LOGD("agl2: glTexImage2D internalformat=0x%.4X format=0x%.4X type=0x%.4X \n", internalformat, format, type); +// LOGD("width=%d height=%d border=%d level=%d pixels=%p \n", width, height, border, level, pixels); + switch (type) { + case GL_UNSIGNED_BYTE: + break; + case GL_UNSIGNED_SHORT_5_6_5: + internalformat = format = GL_UNSIGNED_SHORT_5_6_5; + assert(4 == ctx->tex.unpack); + break; + default: + assert(0); + } + assert(internalformat == format); + assert(0 == border); + if (0 != level) { + LOGD("agl2: glTexImage2D level=%d", level); + return; + } + unsigned bytesPerPixel = 0; + GGLPixelFormat texFormat = GGL_PIXEL_FORMAT_UNKNOWN; + GetFormatAndBytesPerPixel(format, &bytesPerPixel, &texFormat); + + assert(texFormat && bytesPerPixel); +// LOGD("texFormat=0x%.2X bytesPerPixel=%d active=%u", texFormat, bytesPerPixel, ctx->tex.active); + unsigned offset = 0, size = width * height * bytesPerPixel, totalSize = size; + + assert(ctx->tex.tmus[ctx->tex.active]); + + GGLTexture & tex = *ctx->tex.tmus[ctx->tex.active]; + tex.width = width; + tex.height = height; + tex.levelCount = 1; + tex.format = texFormat; + + switch (target) { + case GL_TEXTURE_2D: + assert(GL_TEXTURE_2D == ctx->tex.tmus[ctx->tex.active]->type); + offset = 0; + break; + break; + case GL_TEXTURE_CUBE_MAP_POSITIVE_X: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_X: + case GL_TEXTURE_CUBE_MAP_POSITIVE_Y: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Y: + case GL_TEXTURE_CUBE_MAP_POSITIVE_Z: + case GL_TEXTURE_CUBE_MAP_NEGATIVE_Z: + assert(GL_TEXTURE_CUBE_MAP == ctx->tex.tmus[ctx->tex.active]->type); + assert(width == height); + offset = (target - GL_TEXTURE_CUBE_MAP_POSITIVE_X) * size; + totalSize = 6 * size; + break; + default: + assert(0); + return; + } + + tex.levels = realloc(tex.levels, totalSize); + if (pixels) + CopyTexture((char *)tex.levels, (const char *)pixels, bytesPerPixel, 0, 0, width, 0, 0, width, width, height); + ctx->tex.UpdateSampler(ctx->iface, ctx->tex.active); +} + +void glTexParameterf(GLenum target, GLenum pname, GLfloat param) +{ +// LOGD("agl2: glTexParameterf target=0x%.4X pname=0x%.4X param=%f", target, pname, param); + glTexParameteri(target, pname, param); +} +void API_ENTRY(glTexParameterfv)(GLenum target, GLenum pname, const GLfloat* params) +{ + CALL_GL_API(glTexParameterfv, target, pname, params); +} +void glTexParameteri(GLenum target, GLenum pname, GLint param) +{ + GLES2_GET_CONST_CONTEXT(ctx); +// LOGD("alg2: glTexParameteri target=0x%.0X pname=0x%.4X param=0x%.4X", +// target, pname, param); + assert(ctx->tex.tmus[ctx->tex.active]); + assert(target == ctx->tex.tmus[ctx->tex.active]->type); + GGLTexture & tex = *ctx->tex.tmus[ctx->tex.active]; + switch (pname) { + case GL_TEXTURE_WRAP_S: + case GL_TEXTURE_WRAP_T: + GGLTexture::GGLTextureWrap wrap; + switch (param) { + case GL_REPEAT: + wrap = GGLTexture::GGL_REPEAT; + break; + case GL_CLAMP_TO_EDGE: + wrap = GGLTexture::GGL_CLAMP_TO_EDGE; + break; + case GL_MIRRORED_REPEAT: + wrap = GGLTexture::GGL_MIRRORED_REPEAT; + break; + default: + assert(0); + return; + } + if (GL_TEXTURE_WRAP_S == pname) + tex.wrapS = wrap; + else + tex.wrapT = wrap; + break; + case GL_TEXTURE_MIN_FILTER: + switch (param) { + case GL_NEAREST: + tex.minFilter = GGLTexture::GGL_NEAREST; + break; + case GL_LINEAR: + tex.minFilter = GGLTexture::GGL_LINEAR; + break; + case GL_NEAREST_MIPMAP_NEAREST: +// tex.minFilter = GGLTexture::GGL_NEAREST_MIPMAP_NEAREST; + break; + case GL_NEAREST_MIPMAP_LINEAR: +// tex.minFilter = GGLTexture::GGL_NEAREST_MIPMAP_LINEAR; + break; + case GL_LINEAR_MIPMAP_NEAREST: +// tex.minFilter = GGLTexture::GGL_LINEAR_MIPMAP_NEAREST; + break; + case GL_LINEAR_MIPMAP_LINEAR: +// tex.minFilter = GGLTexture::GGL_LINEAR_MIPMAP_LINEAR; + break; + default: + assert(0); + return; + } + break; + case GL_TEXTURE_MAG_FILTER: + switch (param) { + case GL_NEAREST: + tex.minFilter = GGLTexture::GGL_NEAREST; + break; + case GL_LINEAR: + tex.minFilter = GGLTexture::GGL_LINEAR; + break; + default: + assert(0); + return; + } + break; + default: + assert(0); + return; + } + // implementation restriction + if (tex.magFilter != tex.minFilter) + tex.magFilter = tex.minFilter = GGLTexture::GGL_LINEAR; + ctx->tex.UpdateSampler(ctx->iface, ctx->tex.active); +} +void API_ENTRY(glTexParameteriv)(GLenum target, GLenum pname, const GLint* params) +{ + CALL_GL_API(glTexParameteriv, target, pname, params); +} +void glTexSubImage2D(GLenum target, GLint level, GLint xoffset, GLint yoffset, GLsizei width, GLsizei height, GLenum format, GLenum type, const GLvoid* pixels) +{ + GLES2_GET_CONST_CONTEXT(ctx); +// LOGD("agl2: glTexSubImage2D target=0x%.4X level=%d xoffset=%d yoffset=%d width=%d height=%d format=0x%.4X type=0x%.4X pixels=%p", +// target, level, xoffset, yoffset, width, height, format, type, pixels); + assert(0 == level); + assert(target == ctx->tex.tmus[ctx->tex.active]->type); + switch (type) { + case GL_UNSIGNED_BYTE: + break; + case GL_UNSIGNED_SHORT_5_6_5: + format = GL_UNSIGNED_SHORT_5_6_5; + assert(4 == ctx->tex.unpack); + break; + default: + assert(0); + } + GGLTexture & tex = *ctx->tex.tmus[ctx->tex.active]; + GGLPixelFormat texFormat = GGL_PIXEL_FORMAT_UNKNOWN; + unsigned bytesPerPixel = 0; + GetFormatAndBytesPerPixel(format, &bytesPerPixel, &texFormat); + assert(texFormat == tex.format); + assert(GL_UNSIGNED_BYTE == type); + switch (target) { + case GL_TEXTURE_2D: + CopyTexture((char *)tex.levels, (const char *)pixels, bytesPerPixel, 0, 0, width, xoffset, + yoffset, tex.width, width, height); + break; + default: + assert(0); + } + ctx->tex.UpdateSampler(ctx->iface, ctx->tex.active); +} diff --git a/opengl/libagl2/src/vertex.cpp b/opengl/libagl2/src/vertex.cpp new file mode 100644 index 0000000..021b82b --- /dev/null +++ b/opengl/libagl2/src/vertex.cpp @@ -0,0 +1,373 @@ +#include "gles2context.h" + +//#undef LOGD +//#define LOGD(...) + +void GLES2Context::InitializeVertices() +{ + vert.vbos = std::map(); // the entire struct has been zeroed in constructor + vert.free = 1; + vert.vbo = NULL; + vert.indices = NULL; + for (unsigned i = 0; i < GGL_MAXVERTEXATTRIBS; i++) + vert.defaultAttribs[i] = Vector4(0,0,0,1); +} + +void GLES2Context::UninitializeVertices() +{ + for (std::map::iterator it = vert.vbos.begin(); it != vert.vbos.end(); it++) { + if (!it->second) + continue; + free(it->second->data); + free(it->second); + } +} + +static inline void FetchElement(const GLES2Context * ctx, const unsigned index, + const unsigned maxAttrib, VertexInput * elem) +{ + for (unsigned i = 0; i < maxAttrib; i++) { + { + unsigned size = 0; + if (ctx->vert.attribs[i].enabled) { + const char * ptr = (const char *)ctx->vert.attribs[i].ptr; + ptr += ctx->vert.attribs[i].stride * index; + memcpy(elem->attributes + i, ptr, ctx->vert.attribs[i].size * sizeof(float)); + size = ctx->vert.attribs[i].size; +// LOGD("agl2: FetchElement %d attribs size=%d %.2f,%.2f,%.2f,%.2f", i, size, elem->attributes[i].x, +// elem->attributes[i].y, elem->attributes[i].z, elem->attributes[i].w); + } else { +// LOGD("agl2: FetchElement %d default %.2f,%.2f,%.2f,%.2f", i, ctx->vert.defaultAttribs[i].x, +// ctx->vert.defaultAttribs[i].y, ctx->vert.defaultAttribs[i].z, ctx->vert.defaultAttribs[i].w); + } + + switch (size) { + case 0: // fall through + elem->attributes[i].x = ctx->vert.defaultAttribs[i].x; + case 1: // fall through + elem->attributes[i].y = ctx->vert.defaultAttribs[i].y; + case 2: // fall through + elem->attributes[i].z = ctx->vert.defaultAttribs[i].z; + case 3: // fall through + elem->attributes[i].w = ctx->vert.defaultAttribs[i].w; + case 4: + break; + default: + assert(0); + break; + } +// LOGD("agl2: FetchElement %d size=%d %.2f,%.2f,%.2f,%.2f", i, size, elem->attributes[i].x, +// elem->attributes[i].y, elem->attributes[i].z, elem->attributes[i].w); + } + } +} + +template static void DrawElementsTriangles(const GLES2Context * ctx, + const unsigned count, const IndexT * indices, const unsigned maxAttrib) +{ + VertexInput v[3]; + if (ctx->vert.indices) + indices = (IndexT *)((char *)ctx->vert.indices->data + (long)indices); + for (unsigned i = 0; i < count; i += 3) { + for (unsigned j = 0; j < 3; j++) + FetchElement(ctx, indices[i + j], maxAttrib, v + j); + ctx->iface->DrawTriangle(ctx->iface, v, v + 1, v + 2); + } +} + +static void DrawArraysTriangles(const GLES2Context * ctx, const unsigned first, + const unsigned count, const unsigned maxAttrib) +{ +// LOGD("agl: DrawArraysTriangles=%p", DrawArraysTriangles); + VertexInput v[3]; + for (unsigned i = 2; i < count; i+=3) { + // TODO: fix order + FetchElement(ctx, first + i - 2, maxAttrib, v + 0); + FetchElement(ctx, first + i - 1, maxAttrib, v + 1); + FetchElement(ctx, first + i - 0, maxAttrib, v + 2); + ctx->iface->DrawTriangle(ctx->iface, v + 0, v + 1, v + 2); + } +// LOGD("agl: DrawArraysTriangles end"); +} + +template static void DrawElementsTriangleStrip(const GLES2Context * ctx, + const unsigned count, const IndexT * indices, const unsigned maxAttrib) +{ + VertexInput v[3]; + if (ctx->vert.indices) + indices = (IndexT *)((char *)ctx->vert.indices->data + (long)indices); + +// LOGD("agl2: DrawElementsTriangleStrip"); +// for (unsigned i = 0; i < count; i++) +// LOGD("indices[%d] = %d", i, indices[i]); + + FetchElement(ctx, indices[0], maxAttrib, v + 0); + FetchElement(ctx, indices[1], maxAttrib, v + 1); + for (unsigned i = 2; i < count; i ++) { + FetchElement(ctx, indices[i], maxAttrib, v + i % 3); + ctx->iface->DrawTriangle(ctx->iface, v + (i - 2) % 3, v + (i - 1) % 3 , v + (i + 0) % 3); + } + +// for (unsigned i = 2; i < count; i++) { +// FetchElement(ctx, indices[i - 2], maxAttrib, v + 0); +// FetchElement(ctx, indices[i - 1], maxAttrib, v + 1); +// FetchElement(ctx, indices[i - 0], maxAttrib, v + 2); +// ctx->iface->DrawTriangle(ctx->iface, v + 0, v + 1, v + 2); +// } +} + +static void DrawArraysTriangleStrip(const GLES2Context * ctx, const unsigned first, + const unsigned count, const unsigned maxAttrib) +{ + VertexInput v[3]; + FetchElement(ctx, first, maxAttrib, v + 0); + FetchElement(ctx, first + 1, maxAttrib, v + 1); + for (unsigned i = 2; i < count; i++) { + // TODO: fix order + FetchElement(ctx, first + i, maxAttrib, v + i % 3); + ctx->iface->DrawTriangle(ctx->iface, v + (i - 2) % 3, v + (i - 1) % 3 , v + (i + 0) % 3); + } +} + +void glBindBuffer(GLenum target, GLuint buffer) +{ + GLES2_GET_CONST_CONTEXT(ctx); + VBO * vbo = NULL; + if (0 != buffer) { + std::map::iterator it = ctx->vert.vbos.find(buffer); + if (it != ctx->vert.vbos.end()) { + vbo = it->second; + if (!vbo) + vbo = (VBO *)calloc(1, sizeof(VBO)); + it->second = vbo; + } else + assert(0); + } + if (GL_ARRAY_BUFFER == target) + ctx->vert.vbo = vbo; + else if (GL_ELEMENT_ARRAY_BUFFER == target) + ctx->vert.indices = vbo; + else + assert(0); + assert(vbo || buffer == 0); +// LOGD("\n*\n glBindBuffer 0x%.4X=%d ", target, buffer); +} + +void glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage) +{ + GLES2_GET_CONST_CONTEXT(ctx); + if (GL_ARRAY_BUFFER == target) { + assert(ctx->vert.vbo); + ctx->vert.vbo->data = realloc(ctx->vert.vbo->data, size); + ctx->vert.vbo->size = size; + ctx->vert.vbo->usage = usage; + if (data) + memcpy(ctx->vert.vbo->data, data, size); + } else if (GL_ELEMENT_ARRAY_BUFFER == target) { + assert(ctx->vert.indices); + ctx->vert.indices->data = realloc(ctx->vert.indices->data, size); + ctx->vert.indices->size = size; + ctx->vert.indices->usage = usage; + if (data) + memcpy(ctx->vert.indices->data, data, size); + } else + assert(0); +// LOGD("\n*\n glBufferData target=0x%.4X size=%u data=%p usage=0x%.4X \n", +// target, size, data, usage); +} + +void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data) +{ + GLES2_GET_CONST_CONTEXT(ctx); + if (GL_ARRAY_BUFFER == target) + { + assert(ctx->vert.vbo); + assert(0 <= offset); + assert(0 <= size); + assert(offset + size <= ctx->vert.vbo->size); + memcpy((char *)ctx->vert.vbo->data + offset, data, size); + } + else + assert(0); +} + +void glDeleteBuffers(GLsizei n, const GLuint* buffers) +{ + GLES2_GET_CONST_CONTEXT(ctx); + for (unsigned i = 0; i < n; i++) { + std::map::iterator it = ctx->vert.vbos.find(buffers[i]); + if (it == ctx->vert.vbos.end()) + continue; + ctx->vert.free = min(ctx->vert.free, buffers[i]); + if (it->second == ctx->vert.vbo) + ctx->vert.vbo = NULL; + else if (it->second == ctx->vert.indices) + ctx->vert.indices = NULL; + if (it->second) { + free(it->second->data); + free(it->second); + } + } +} + +void glDisableVertexAttribArray(GLuint index) +{ + GLES2_GET_CONST_CONTEXT(ctx); + assert(GGL_MAXVERTEXATTRIBS > index); + ctx->vert.attribs[index].enabled = false; +} + +void glDrawArrays(GLenum mode, GLint first, GLsizei count) +{ + GLES2_GET_CONST_CONTEXT(ctx); +// LOGD("agl2: glDrawArrays=%p", glDrawArrays); + assert(ctx->rasterizer.CurrentProgram); + assert(0 <= first); + int maxAttrib = -1; + ctx->iface->ShaderProgramGetiv(ctx->rasterizer.CurrentProgram, GL_ACTIVE_ATTRIBUTES, &maxAttrib); + assert(0 <= maxAttrib && GGL_MAXVERTEXATTRIBS >= maxAttrib); + switch (mode) { + case GL_TRIANGLE_STRIP: + DrawArraysTriangleStrip(ctx, first, count, maxAttrib); + break; + case GL_TRIANGLES: + DrawArraysTriangles(ctx, first, count, maxAttrib); + break; + default: + LOGE("agl2: glDrawArrays unsupported mode: 0x%.4X \n", mode); + assert(0); + break; + } +// LOGD("agl2: glDrawArrays end"); +} + +void glDrawElements(GLenum mode, GLsizei count, GLenum type, const GLvoid* indices) +{ + GLES2_GET_CONST_CONTEXT(ctx); +// LOGD("agl2: glDrawElements=%p mode=0x%.4X count=%d type=0x%.4X indices=%p", +// glDrawElements, mode, count, type, indices); + if (!ctx->rasterizer.CurrentProgram) + return; + + int maxAttrib = -1; + ctx->iface->ShaderProgramGetiv(ctx->rasterizer.CurrentProgram, GL_ACTIVE_ATTRIBUTES, &maxAttrib); + assert(0 <= maxAttrib && GGL_MAXVERTEXATTRIBS >= maxAttrib); +// LOGD("agl2: glDrawElements mode=0x%.4X type=0x%.4X count=%d program=%p indices=%p \n", +// mode, type, count, ctx->rasterizer.CurrentProgram, indices); + switch (mode) { + case GL_TRIANGLES: + if (GL_UNSIGNED_SHORT == type) + DrawElementsTriangles(ctx, count, (unsigned short *)indices, maxAttrib); + else + assert(0); + break; + case GL_TRIANGLE_STRIP: + if (GL_UNSIGNED_SHORT == type) + DrawElementsTriangleStrip(ctx, count, (unsigned short *)indices, maxAttrib); + else + assert(0); + break; + default: + assert(0); + } +// LOGD("agl2: glDrawElements end"); +} + +void glEnableVertexAttribArray(GLuint index) +{ + GLES2_GET_CONST_CONTEXT(ctx); + ctx->vert.attribs[index].enabled = true; +// LOGD("agl2: glEnableVertexAttribArray %d \n", index); +} + +void glGenBuffers(GLsizei n, GLuint* buffers) +{ + GLES2_GET_CONST_CONTEXT(ctx); + for (unsigned i = 0; i < n; i++) { + buffers[i] = 0; + for (ctx->vert.free; ctx->vert.free < 0xffffffffu; ctx->vert.free++) { + if (ctx->vert.vbos.find(ctx->vert.free) == ctx->vert.vbos.end()) { + ctx->vert.vbos[ctx->vert.free] = NULL; + buffers[i] = ctx->vert.free; +// LOGD("glGenBuffers %d \n", buffers[i]); + ctx->vert.free++; + break; + } + } + assert(buffers[i]); + } +} + +void glVertexAttribPointer(GLuint index, GLint size, GLenum type, GLboolean normalized, + GLsizei stride, const GLvoid* ptr) +{ + GLES2_GET_CONST_CONTEXT(ctx); + assert(GL_FLOAT == type); + assert(0 < size && 4 >= size); + ctx->vert.attribs[index].size = size; + ctx->vert.attribs[index].type = type; + ctx->vert.attribs[index].normalized = normalized; + if (0 == stride) + ctx->vert.attribs[index].stride = size * sizeof(float); + else if (stride > 0) + ctx->vert.attribs[index].stride = stride; + else + assert(0); +// LOGD("\n*\n*\n* agl2: glVertexAttribPointer program=%u index=%d size=%d stride=%d ptr=%p \n*\n*", +// unsigned(ctx->rasterizer.CurrentProgram) ^ 0x04dc18f9, index, size, stride, ptr); + if (ctx->vert.vbo) + ctx->vert.attribs[index].ptr = (char *)ctx->vert.vbo->data + (long)ptr; + else + ctx->vert.attribs[index].ptr = ptr; +// const float * attrib = (const float *)ctx->vert.attribs[index].ptr; +// for (unsigned i = 0; i < 3; i++) +// if (3 == size) +// LOGD("%.2f %.2f %.2f", attrib[i * 3 + 0], attrib[i * 3 + 1], attrib[i * 3 + 2]); +// else if (2 == size) +// LOGD("%.2f %.2f", attrib[i * 3 + 0], attrib[i * 3 + 1]); + +} + +void glVertexAttrib1f(GLuint indx, GLfloat x) +{ + glVertexAttrib4f(indx, x,0,0,1); +} + +void glVertexAttrib1fv(GLuint indx, const GLfloat* values) +{ + glVertexAttrib4f(indx, values[0],0,0,1); +} + +void glVertexAttrib2f(GLuint indx, GLfloat x, GLfloat y) +{ + glVertexAttrib4f(indx, x,y,0,1); +} + +void glVertexAttrib2fv(GLuint indx, const GLfloat* values) +{ + glVertexAttrib4f(indx, values[0],values[1],0,1); +} + +void glVertexAttrib3f(GLuint indx, GLfloat x, GLfloat y, GLfloat z) +{ + glVertexAttrib4f(indx, x,y,z,1); +} + +void glVertexAttrib3fv(GLuint indx, const GLfloat* values) +{ + glVertexAttrib4f(indx, values[0],values[1],values[2],1); +} + +void glVertexAttrib4f(GLuint indx, GLfloat x, GLfloat y, GLfloat z, GLfloat w) +{ + assert(GGL_MAXVERTEXATTRIBS > indx); + GLES2_GET_CONST_CONTEXT(ctx); +// LOGD("\n*\n*\n agl2: glVertexAttrib4f %d %.2f,%.2f,%.2f,%.2f \n*\n*", indx, x, y, z, w); + ctx->vert.defaultAttribs[indx] = Vector4(x,y,z,w); + assert(0); +} + +void glVertexAttrib4fv(GLuint indx, const GLfloat* values) +{ + glVertexAttrib4f(indx, values[0], values[1], values[2], values[3]); +} -- cgit v1.1