auto import from //depot/cupcake/@135843
diff --git a/opengl/libagl/Android.mk b/opengl/libagl/Android.mk
new file mode 100644
index 0000000..99efe4c
--- /dev/null
+++ b/opengl/libagl/Android.mk
@@ -0,0 +1,39 @@
+LOCAL_PATH:= $(call my-dir)
+
+#
+# Build the software OpenGL ES library
+#
+
+include $(CLEAR_VARS)
+
+LOCAL_SRC_FILES:= \
+ egl.cpp \
+ state.cpp \
+ texture.cpp \
+ Tokenizer.cpp \
+ TokenManager.cpp \
+ TextureObjectManager.cpp \
+ BufferObjectManager.cpp \
+ array.cpp.arm \
+ fp.cpp.arm \
+ light.cpp.arm \
+ matrix.cpp.arm \
+ mipmap.cpp.arm \
+ primitives.cpp.arm \
+ vertex.cpp.arm
+
+ifeq ($(TARGET_ARCH),arm)
+ LOCAL_SRC_FILES += fixed_asm.S iterators.S
+ LOCAL_CFLAGS += -fstrict-aliasing
+endif
+
+ifneq ($(TARGET_SIMULATOR),true)
+ # we need to access the private Bionic header <bionic_tls.h>
+ LOCAL_CFLAGS += -I$(LOCAL_PATH)/../../../../bionic/libc/private
+endif
+
+LOCAL_SHARED_LIBRARIES := libcutils libutils libpixelflinger
+LOCAL_LDLIBS := -lpthread -ldl
+LOCAL_MODULE:= libagl
+
+include $(BUILD_SHARED_LIBRARY)
diff --git a/opengl/libagl/BufferObjectManager.cpp b/opengl/libagl/BufferObjectManager.cpp
new file mode 100644
index 0000000..6bf28ee
--- /dev/null
+++ b/opengl/libagl/BufferObjectManager.cpp
@@ -0,0 +1,103 @@
+/*
+ ** Copyright 2008, The Android Open Source Project
+ **
+ ** Licensed under the Apache License, Version 2.0 (the "License");
+ ** you may not use this file except in compliance with the License.
+ ** You may obtain a copy of the License at
+ **
+ ** http://www.apache.org/licenses/LICENSE-2.0
+ **
+ ** Unless required by applicable law or agreed to in writing, software
+ ** distributed under the License is distributed on an "AS IS" BASIS,
+ ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ** See the License for the specific language governing permissions and
+ ** limitations under the License.
+ */
+
+#include <stdint.h>
+#include <stddef.h>
+#include <sys/types.h>
+
+#include <utils/Atomic.h>
+#include <utils/RefBase.h>
+#include <utils/KeyedVector.h>
+#include <utils/Errors.h>
+
+#include <GLES/gl.h>
+
+#include "BufferObjectManager.h"
+
+
+namespace android {
+
+using namespace gl;
+
+// ----------------------------------------------------------------------------
+
+EGLBufferObjectManager::EGLBufferObjectManager()
+: TokenManager(), mCount(0)
+{
+}
+
+EGLBufferObjectManager::~EGLBufferObjectManager()
+{
+ // destroy all the buffer objects and their storage
+ GLsizei n = mBuffers.size();
+ for (GLsizei i=0 ; i<n ; i++) {
+ buffer_t* bo = mBuffers.valueAt(i);
+ free(bo->data);
+ delete bo;
+ }
+}
+
+buffer_t const* EGLBufferObjectManager::bind(GLuint buffer)
+{
+ Mutex::Autolock _l(mLock);
+ int32_t i = mBuffers.indexOfKey(buffer);
+ if (i >= 0) {
+ return mBuffers.valueAt(i);
+ }
+ buffer_t* bo = new buffer_t;
+ bo->data = 0;
+ bo->usage = GL_STATIC_DRAW;
+ bo->size = 0;
+ bo->name = buffer;
+ mBuffers.add(buffer, bo);
+ return bo;
+}
+
+int EGLBufferObjectManager::allocateStore(buffer_t* bo,
+ GLsizeiptr size, GLenum usage)
+{
+ Mutex::Autolock _l(mLock);
+ if (size != bo->size) {
+ uint8_t* data = (uint8_t*)malloc(size);
+ if (data == 0)
+ return -1;
+ free(bo->data);
+ bo->data = data;
+ bo->size = size;
+ }
+ bo->usage = usage;
+ return 0;
+}
+
+void EGLBufferObjectManager::deleteBuffers(GLsizei n, const GLuint* buffers)
+{
+ Mutex::Autolock _l(mLock);
+ while (n--) {
+ const GLuint t = *buffers++;
+ if (t) {
+ int32_t index = mBuffers.indexOfKey(t);
+ if (index >= 0) {
+ buffer_t* bo = mBuffers.valueAt(index);
+ free(bo->data);
+ mBuffers.removeItemsAt(index);
+ delete bo;
+ }
+ }
+ }
+}
+
+// ----------------------------------------------------------------------------
+}; // namespace android
diff --git a/opengl/libagl/BufferObjectManager.h b/opengl/libagl/BufferObjectManager.h
new file mode 100644
index 0000000..9e9340a
--- /dev/null
+++ b/opengl/libagl/BufferObjectManager.h
@@ -0,0 +1,85 @@
+/*
+ **
+ ** Copyright 2006, The Android Open Source Project
+ **
+ ** Licensed under the Apache License, Version 2.0 (the "License");
+ ** you may not use this file except in compliance with the License.
+ ** You may obtain a copy of the License at
+ **
+ ** http://www.apache.org/licenses/LICENSE-2.0
+ **
+ ** Unless required by applicable law or agreed to in writing, software
+ ** distributed under the License is distributed on an "AS IS" BASIS,
+ ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ** See the License for the specific language governing permissions and
+ ** limitations under the License.
+ */
+
+#ifndef ANDROID_OPENGLES_BUFFER_OBJECT_MANAGER_H
+#define ANDROID_OPENGLES_BUFFER_OBJECT_MANAGER_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include <sys/types.h>
+
+#include <utils/Atomic.h>
+#include <utils/RefBase.h>
+#include <utils/KeyedVector.h>
+#include <utils/Errors.h>
+
+#include <GLES/gl.h>
+
+#include "Tokenizer.h"
+#include "TokenManager.h"
+
+
+namespace android {
+
+// ----------------------------------------------------------------------------
+
+namespace gl {
+
+struct buffer_t {
+ GLsizeiptr size;
+ GLenum usage;
+ uint8_t* data;
+ uint32_t name;
+};
+
+};
+
+class EGLBufferObjectManager : public TokenManager
+{
+public:
+ EGLBufferObjectManager();
+ ~EGLBufferObjectManager();
+
+ // protocol for sp<>
+ inline void incStrong(const void* id) const;
+ inline void decStrong(const void* id) const;
+ typedef void weakref_type;
+
+ gl::buffer_t const* bind(GLuint buffer);
+ int allocateStore(gl::buffer_t* bo, GLsizeiptr size, GLenum usage);
+ void deleteBuffers(GLsizei n, const GLuint* buffers);
+
+private:
+ mutable volatile int32_t mCount;
+ mutable Mutex mLock;
+ KeyedVector<GLuint, gl::buffer_t*> mBuffers;
+};
+
+void EGLBufferObjectManager::incStrong(const void* id) const {
+ android_atomic_inc(&mCount);
+}
+void EGLBufferObjectManager::decStrong(const void* id) const {
+ if (android_atomic_dec(&mCount) == 1) {
+ delete this;
+ }
+}
+
+// ----------------------------------------------------------------------------
+}; // namespace android
+
+#endif // ANDROID_OPENGLES_BUFFER_OBJECT_MANAGER_H
+
diff --git a/opengl/libagl/TextureObjectManager.cpp b/opengl/libagl/TextureObjectManager.cpp
new file mode 100644
index 0000000..ce31854
--- /dev/null
+++ b/opengl/libagl/TextureObjectManager.cpp
@@ -0,0 +1,309 @@
+/*
+ ** Copyright 2006, The Android Open Source Project
+ **
+ ** Licensed under the Apache License, Version 2.0 (the "License");
+ ** you may not use this file except in compliance with the License.
+ ** You may obtain a copy of the License at
+ **
+ ** http://www.apache.org/licenses/LICENSE-2.0
+ **
+ ** Unless required by applicable law or agreed to in writing, software
+ ** distributed under the License is distributed on an "AS IS" BASIS,
+ ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ ** See the License for the specific language governing permissions and
+ ** limitations under the License.
+ */
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "context.h"
+#include "TextureObjectManager.h"
+
+namespace android {
+// ----------------------------------------------------------------------------
+
+EGLTextureObject::EGLTextureObject()
+ : mCount(0), mSize(0)
+{
+ init();
+}
+
+EGLTextureObject::~EGLTextureObject()
+{
+ if (!direct) {
+ if (mSize && surface.data)
+ free(surface.data);
+ if (mMipmaps)
+ freeMipmaps();
+ }
+}
+
+void EGLTextureObject::init()
+{
+ memset(&surface, 0, sizeof(surface));
+ surface.version = sizeof(surface);
+ mMipmaps = 0;
+ mNumExtraLod = 0;
+ mIsComplete = false;
+ wraps = GL_REPEAT;
+ wrapt = GL_REPEAT;
+ min_filter = GL_LINEAR;
+ mag_filter = GL_LINEAR;
+ internalformat = 0;
+ memset(crop_rect, 0, sizeof(crop_rect));
+ generate_mipmap = GL_FALSE;
+ direct = GL_FALSE;
+}
+
+void EGLTextureObject::copyParameters(const sp<EGLTextureObject>& old)
+{
+ wraps = old->wraps;
+ wrapt = old->wrapt;
+ min_filter = old->min_filter;
+ mag_filter = old->mag_filter;
+ memcpy(crop_rect, old->crop_rect, sizeof(crop_rect));
+ generate_mipmap = old->generate_mipmap;
+ direct = old->direct;
+}
+
+status_t EGLTextureObject::allocateMipmaps()
+{
+ // here, by construction, mMipmaps=0 && mNumExtraLod=0
+
+ if (!surface.data)
+ return NO_INIT;
+
+ int w = surface.width;
+ int h = surface.height;
+ const int numLods = 31 - gglClz(max(w,h));
+ if (numLods <= 0)
+ return NO_ERROR;
+
+ mMipmaps = (GGLSurface*)malloc(numLods * sizeof(GGLSurface));
+ if (!mMipmaps)
+ return NO_MEMORY;
+
+ memset(mMipmaps, 0, numLods * sizeof(GGLSurface));
+ mNumExtraLod = numLods;
+ return NO_ERROR;
+}
+
+void EGLTextureObject::freeMipmaps()
+{
+ if (mMipmaps) {
+ for (int i=0 ; i<mNumExtraLod ; i++) {
+ if (mMipmaps[i].data) {
+ free(mMipmaps[i].data);
+ }
+ }
+ free(mMipmaps);
+ mMipmaps = 0;
+ mNumExtraLod = 0;
+ }
+}
+
+const GGLSurface& EGLTextureObject::mip(int lod) const
+{
+ if (lod<=0 || !mMipmaps)
+ return surface;
+ lod = min(lod-1, mNumExtraLod-1);
+ return mMipmaps[lod];
+}
+
+GGLSurface& EGLTextureObject::editMip(int lod)
+{
+ return const_cast<GGLSurface&>(mip(lod));
+}
+
+status_t EGLTextureObject::setSurface(GGLSurface const* s)
+{
+ // XXX: glFlush() on 's'
+ if (mSize && surface.data) {
+ free(surface.data);
+ }
+ surface = *s;
+ internalformat = 0;
+
+ // we should keep the crop_rect, but it's delicate because
+ // the new size of the surface could make it invalid.
+ // so for now, we just loose it.
+ memset(crop_rect, 0, sizeof(crop_rect));
+
+ // it would be nice if we could keep the generate_mipmap flag,
+ // we would have to generate them right now though.
+ generate_mipmap = GL_FALSE;
+
+ direct = GL_TRUE;
+ mSize = 0; // we don't own this surface
+ if (mMipmaps)
+ freeMipmaps();
+ mIsComplete = true;
+ return NO_ERROR;
+}
+
+status_t EGLTextureObject::reallocate(
+ GLint level, int w, int h, int s,
+ int format, int compressedFormat, int bpr)
+{
+ const size_t size = h * bpr;
+ if (level == 0)
+ {
+ if (size!=mSize || !surface.data) {
+ if (mSize && surface.data) {
+ free(surface.data);
+ }
+ surface.data = (GGLubyte*)malloc(size);
+ if (!surface.data) {
+ mSize = 0;
+ mIsComplete = false;
+ return NO_MEMORY;
+ }
+ mSize = size;
+ }
+ surface.version = sizeof(GGLSurface);
+ surface.width = w;
+ surface.height = h;
+ surface.stride = s;
+ surface.format = format;
+ surface.compressedFormat = compressedFormat;
+ if (mMipmaps)
+ freeMipmaps();
+ mIsComplete = true;
+ }
+ else
+ {
+ if (!mMipmaps) {
+ if (allocateMipmaps() != NO_ERROR)
+ return NO_MEMORY;
+ }
+
+ LOGW_IF(level-1 >= mNumExtraLod,
+ "specifying mipmap level %d, but # of level is %d",
+ level, mNumExtraLod+1);
+
+ GGLSurface& mipmap = editMip(level);
+ if (mipmap.data)
+ free(mipmap.data);
+
+ mipmap.data = (GGLubyte*)malloc(size);
+ if (!mipmap.data) {
+ memset(&mipmap, 0, sizeof(GGLSurface));
+ mIsComplete = false;
+ return NO_MEMORY;
+ }
+
+ mipmap.version = sizeof(GGLSurface);
+ mipmap.width = w;
+ mipmap.height = h;
+ mipmap.stride = s;
+ mipmap.format = format;
+ mipmap.compressedFormat = compressedFormat;
+
+ // check if the texture is complete
+ mIsComplete = true;
+ const GGLSurface* prev = &surface;
+ for (int i=0 ; i<mNumExtraLod ; i++) {
+ const GGLSurface* curr = mMipmaps + i;
+ if (curr->format != surface.format) {
+ mIsComplete = false;
+ break;
+ }
+
+ uint32_t w = (prev->width >> 1) ? : 1;
+ uint32_t h = (prev->height >> 1) ? : 1;
+ if (w != curr->width || h != curr->height) {
+ mIsComplete = false;
+ break;
+ }
+ prev = curr;
+ }
+ }
+ return NO_ERROR;
+}
+
+// ----------------------------------------------------------------------------
+
+EGLSurfaceManager::EGLSurfaceManager()
+ : TokenManager(), mCount(0)
+{
+}
+
+EGLSurfaceManager::~EGLSurfaceManager()
+{
+ // everything gets freed automatically here...
+}
+
+sp<EGLTextureObject> EGLSurfaceManager::createTexture(GLuint name)
+{
+ sp<EGLTextureObject> result;
+
+ Mutex::Autolock _l(mLock);
+ if (mTextures.indexOfKey(name) >= 0)
+ return result; // already exists!
+
+ result = new EGLTextureObject();
+
+ status_t err = mTextures.add(name, result);
+ if (err < 0)
+ result.clear();
+
+ return result;
+}
+
+sp<EGLTextureObject> EGLSurfaceManager::removeTexture(GLuint name)
+{
+ Mutex::Autolock _l(mLock);
+ const ssize_t index = mTextures.indexOfKey(name);
+ if (index >= 0) {
+ sp<EGLTextureObject> result(mTextures.valueAt(index));
+ mTextures.removeItemsAt(index);
+ return result;
+ }
+ return 0;
+}
+
+sp<EGLTextureObject> EGLSurfaceManager::replaceTexture(GLuint name)
+{
+ sp<EGLTextureObject> tex;
+ Mutex::Autolock _l(mLock);
+ const ssize_t index = mTextures.indexOfKey(name);
+ if (index >= 0) {
+ const sp<EGLTextureObject>& old = mTextures.valueAt(index);
+ const uint32_t refs = old->getStrongCount();
+ if (ggl_likely(refs == 1)) {
+ // we're the only owner
+ tex = old;
+ } else {
+ // keep the texture's parameters
+ tex = new EGLTextureObject();
+ tex->copyParameters(old);
+ mTextures.removeItemsAt(index);
+ mTextures.add(name, tex);
+ }
+ }
+ return tex;
+}
+
+void EGLSurfaceManager::deleteTextures(GLsizei n, const GLuint *tokens)
+{
+ // free all textures
+ Mutex::Autolock _l(mLock);
+ for (GLsizei i=0 ; i<n ; i++) {
+ const GLuint t(*tokens++);
+ if (t) {
+ mTextures.removeItem(t);
+ }
+ }
+}
+
+sp<EGLTextureObject> EGLSurfaceManager::texture(GLuint name)
+{
+ Mutex::Autolock _l(mLock);
+ const ssize_t index = mTextures.indexOfKey(name);
+ if (index >= 0)
+ return mTextures.valueAt(index);
+ return 0;
+}
+
+// ----------------------------------------------------------------------------
+}; // namespace android
diff --git a/opengl/libagl/TextureObjectManager.h b/opengl/libagl/TextureObjectManager.h
new file mode 100644
index 0000000..74ed1a4
--- /dev/null
+++ b/opengl/libagl/TextureObjectManager.h
@@ -0,0 +1,140 @@
+/*
+** Copyright 2006, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+** http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+#ifndef ANDROID_OPENGLES_SURFACE_H
+#define ANDROID_OPENGLES_SURFACE_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include <sys/types.h>
+
+#include <utils/Atomic.h>
+#include <utils/threads.h>
+#include <utils/RefBase.h>
+#include <utils/KeyedVector.h>
+#include <utils/Errors.h>
+
+#include <private/pixelflinger/ggl_context.h>
+
+#include <GLES/gl.h>
+
+#include "Tokenizer.h"
+#include "TokenManager.h"
+
+
+namespace android {
+
+// ----------------------------------------------------------------------------
+
+class EGLTextureObject
+{
+public:
+ EGLTextureObject();
+ ~EGLTextureObject();
+
+ // protocol for sp<>
+ inline void incStrong(const void* id) const;
+ inline void decStrong(const void* id) const;
+ inline uint32_t getStrongCount() const;
+
+ status_t setSurface(GGLSurface const* s);
+ status_t reallocate(GLint level,
+ int w, int h, int s,
+ int format, int compressedFormat, int bpr);
+ inline size_t size() const;
+ const GGLSurface& mip(int lod) const;
+ GGLSurface& editMip(int lod);
+ bool hasMipmaps() const { return mMipmaps!=0; }
+ bool isComplete() const { return mIsComplete; }
+ void copyParameters(const sp<EGLTextureObject>& old);
+
+private:
+ status_t allocateMipmaps();
+ void freeMipmaps();
+ void init();
+ mutable int32_t mCount;
+ size_t mSize;
+ GGLSurface *mMipmaps;
+ int mNumExtraLod;
+ bool mIsComplete;
+
+public:
+ GGLSurface surface;
+ GLenum wraps;
+ GLenum wrapt;
+ GLenum min_filter;
+ GLenum mag_filter;
+ GLenum internalformat;
+ GLint crop_rect[4];
+ GLint generate_mipmap;
+ GLint direct;
+};
+
+void EGLTextureObject::incStrong(const void* id) const {
+ android_atomic_inc(&mCount);
+}
+void EGLTextureObject::decStrong(const void* id) const {
+ if (android_atomic_dec(&mCount) == 1) {
+ delete this;
+ }
+}
+uint32_t EGLTextureObject::getStrongCount() const {
+ return mCount;
+}
+size_t EGLTextureObject::size() const {
+ return mSize;
+}
+
+// ----------------------------------------------------------------------------
+
+class EGLSurfaceManager : public TokenManager
+{
+public:
+ EGLSurfaceManager();
+ ~EGLSurfaceManager();
+
+ // protocol for sp<>
+ inline void incStrong(const void* id) const;
+ inline void decStrong(const void* id) const;
+ typedef void weakref_type;
+
+ sp<EGLTextureObject> createTexture(GLuint name);
+ sp<EGLTextureObject> removeTexture(GLuint name);
+ sp<EGLTextureObject> replaceTexture(GLuint name);
+ void deleteTextures(GLsizei n, const GLuint *tokens);
+ sp<EGLTextureObject> texture(GLuint name);
+
+private:
+ mutable int32_t mCount;
+ mutable Mutex mLock;
+ KeyedVector< GLuint, sp<EGLTextureObject> > mTextures;
+};
+
+void EGLSurfaceManager::incStrong(const void* id) const {
+ android_atomic_inc(&mCount);
+}
+void EGLSurfaceManager::decStrong(const void* id) const {
+ if (android_atomic_dec(&mCount) == 1) {
+ delete this;
+ }
+}
+
+
+// ----------------------------------------------------------------------------
+}; // namespace android
+
+#endif // ANDROID_OPENGLES_SURFACE_H
+
diff --git a/opengl/libagl/TokenManager.cpp b/opengl/libagl/TokenManager.cpp
new file mode 100644
index 0000000..eea6025
--- /dev/null
+++ b/opengl/libagl/TokenManager.cpp
@@ -0,0 +1,62 @@
+/* libs/opengles/surface.cpp
+**
+** Copyright 2006, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+** http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "TokenManager.h"
+
+namespace android {
+// ----------------------------------------------------------------------------
+
+TokenManager::TokenManager()
+{
+ // token 0 is always reserved
+ mTokenizer.reserve(0);
+}
+
+TokenManager::~TokenManager()
+{
+}
+
+status_t TokenManager::getToken(GLsizei n, GLuint *tokens)
+{
+ Mutex::Autolock _l(mLock);
+ for (GLsizei i=0 ; i<n ; i++)
+ *tokens++ = mTokenizer.acquire();
+ return NO_ERROR;
+}
+
+void TokenManager::recycleTokens(GLsizei n, const GLuint *tokens)
+{
+ Mutex::Autolock _l(mLock);
+ for (int i=0 ; i<n ; i++) {
+ const GLuint token = *tokens++;
+ if (token) {
+ mTokenizer.release(token);
+ }
+ }
+}
+
+bool TokenManager::isTokenValid(GLuint token) const
+{
+ Mutex::Autolock _l(mLock);
+ return mTokenizer.isAcquired(token);
+}
+
+// ----------------------------------------------------------------------------
+}; // namespace android
+
diff --git a/opengl/libagl/TokenManager.h b/opengl/libagl/TokenManager.h
new file mode 100644
index 0000000..49c1469
--- /dev/null
+++ b/opengl/libagl/TokenManager.h
@@ -0,0 +1,53 @@
+/*
+** Copyright 2006, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+** http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+#ifndef ANDROID_OPENGLES_TOKEN_MANAGER_H
+#define ANDROID_OPENGLES_TOKEN_MANAGER_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include <sys/types.h>
+
+#include <utils/threads.h>
+
+#include <GLES/gl.h>
+
+#include "Tokenizer.h"
+
+namespace android {
+
+// ----------------------------------------------------------------------------
+
+class TokenManager
+{
+public:
+ TokenManager();
+ ~TokenManager();
+
+ status_t getToken(GLsizei n, GLuint *tokens);
+ void recycleTokens(GLsizei n, const GLuint *tokens);
+ bool isTokenValid(GLuint token) const;
+
+private:
+ mutable Mutex mLock;
+ Tokenizer mTokenizer;
+};
+
+// ----------------------------------------------------------------------------
+}; // namespace android
+
+#endif // ANDROID_OPENGLES_TOKEN_MANAGER_H
+
diff --git a/opengl/libagl/Tokenizer.cpp b/opengl/libagl/Tokenizer.cpp
new file mode 100644
index 0000000..9b3ea1a
--- /dev/null
+++ b/opengl/libagl/Tokenizer.cpp
@@ -0,0 +1,173 @@
+/* libs/opengles/Tokenizer.cpp
+**
+** Copyright 2006, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+** http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+#include <stdio.h>
+
+#include "Tokenizer.h"
+
+// ----------------------------------------------------------------------------
+
+namespace android {
+
+ANDROID_BASIC_TYPES_TRAITS(Tokenizer::run_t)
+
+Tokenizer::Tokenizer()
+{
+}
+
+Tokenizer::Tokenizer(const Tokenizer& other)
+ : mRanges(other.mRanges)
+{
+}
+
+Tokenizer::~Tokenizer()
+{
+}
+
+uint32_t Tokenizer::acquire()
+{
+ if (!mRanges.size() || mRanges[0].first) {
+ _insertTokenAt(0,0);
+ return 0;
+ }
+
+ // just extend the first run
+ const run_t& run = mRanges[0];
+ uint32_t token = run.first + run.length;
+ _insertTokenAt(token, 1);
+ return token;
+}
+
+bool Tokenizer::isAcquired(uint32_t token) const
+{
+ return (_indexOrderOf(token) >= 0);
+}
+
+status_t Tokenizer::reserve(uint32_t token)
+{
+ size_t o;
+ const ssize_t i = _indexOrderOf(token, &o);
+ if (i >= 0) {
+ return BAD_VALUE; // this token is already taken
+ }
+ ssize_t err = _insertTokenAt(token, o);
+ return (err<0) ? err : status_t(NO_ERROR);
+}
+
+status_t Tokenizer::release(uint32_t token)
+{
+ const ssize_t i = _indexOrderOf(token);
+ if (i >= 0) {
+ const run_t& run = mRanges[i];
+ if ((token >= run.first) && (token < run.first+run.length)) {
+ // token in this range, we need to split
+ run_t& run = mRanges.editItemAt(i);
+ if ((token == run.first) || (token == run.first+run.length-1)) {
+ if (token == run.first) {
+ run.first += 1;
+ }
+ run.length -= 1;
+ if (run.length == 0) {
+ // XXX: should we systematically remove a run that's empty?
+ mRanges.removeItemsAt(i);
+ }
+ } else {
+ // split the run
+ run_t new_run;
+ new_run.first = token+1;
+ new_run.length = run.first+run.length - new_run.first;
+ run.length = token - run.first;
+ mRanges.insertAt(new_run, i+1);
+ }
+ return NO_ERROR;
+ }
+ }
+ return NAME_NOT_FOUND;
+}
+
+ssize_t Tokenizer::_indexOrderOf(uint32_t token, size_t* order) const
+{
+ // binary search
+ ssize_t err = NAME_NOT_FOUND;
+ ssize_t l = 0;
+ ssize_t h = mRanges.size()-1;
+ ssize_t mid;
+ const run_t* a = mRanges.array();
+ while (l <= h) {
+ mid = l + (h - l)/2;
+ const run_t* const curr = a + mid;
+ int c = 0;
+ if (token < curr->first) c = 1;
+ else if (token >= curr->first+curr->length) c = -1;
+ if (c == 0) {
+ err = l = mid;
+ break;
+ } else if (c < 0) {
+ l = mid + 1;
+ } else {
+ h = mid - 1;
+ }
+ }
+ if (order) *order = l;
+ return err;
+}
+
+ssize_t Tokenizer::_insertTokenAt(uint32_t token, size_t index)
+{
+ const size_t c = mRanges.size();
+
+ if (index >= 1) {
+ // do we need to merge with the previous run?
+ run_t& p = mRanges.editItemAt(index-1);
+ if (p.first+p.length == token) {
+ p.length += 1;
+ if (index < c) {
+ const run_t& n = mRanges[index];
+ if (token+1 == n.first) {
+ p.length += n.length;
+ mRanges.removeItemsAt(index);
+ }
+ }
+ return index;
+ }
+ }
+
+ if (index < c) {
+ // do we need to merge with the next run?
+ run_t& n = mRanges.editItemAt(index);
+ if (token+1 == n.first) {
+ n.first -= 1;
+ n.length += 1;
+ return index;
+ }
+ }
+
+ return mRanges.insertAt(run_t(token,1), index);
+}
+
+void Tokenizer::dump() const
+{
+ const run_t* ranges = mRanges.array();
+ const size_t c = mRanges.size();
+ LOGD("Tokenizer (%p, size = %u)\n", this, c);
+ for (size_t i=0 ; i<c ; i++) {
+ LOGD("%u: (%u, %u)\n", i, ranges[i].first, ranges[i].length);
+ }
+}
+
+}; // namespace android
+
diff --git a/opengl/libagl/Tokenizer.h b/opengl/libagl/Tokenizer.h
new file mode 100644
index 0000000..ac555cb
--- /dev/null
+++ b/opengl/libagl/Tokenizer.h
@@ -0,0 +1,59 @@
+/* libs/opengles/Tokenizer.h
+**
+** Copyright 2006, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+** http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+
+#ifndef ANDROID_OPENGLES_TOKENIZER_H
+#define ANDROID_OPENGLES_TOKENIZER_H
+
+#include <utils/Vector.h>
+#include <utils/Errors.h>
+
+// ----------------------------------------------------------------------------
+
+namespace android {
+
+class Tokenizer
+{
+public:
+ Tokenizer();
+ Tokenizer(const Tokenizer& other);
+ ~Tokenizer();
+
+ uint32_t acquire();
+ status_t reserve(uint32_t token);
+ status_t release(uint32_t token);
+ bool isAcquired(uint32_t token) const;
+
+ void dump() const;
+
+ struct run_t {
+ run_t() {};
+ run_t(uint32_t f, uint32_t l) : first(f), length(l) {}
+ uint32_t first;
+ uint32_t length;
+ };
+private:
+ ssize_t _indexOrderOf(uint32_t token, size_t* order=0) const;
+ ssize_t _insertTokenAt(uint32_t token, size_t index);
+ Vector<run_t> mRanges;
+};
+
+}; // namespace android
+
+// ----------------------------------------------------------------------------
+
+#endif // ANDROID_OPENGLES_TOKENIZER_H
diff --git a/opengl/libagl/array.cpp b/opengl/libagl/array.cpp
new file mode 100644
index 0000000..8fa7566
--- /dev/null
+++ b/opengl/libagl/array.cpp
@@ -0,0 +1,1557 @@
+/*
+** Copyright 2006, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+** http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "context.h"
+#include "fp.h"
+#include "state.h"
+#include "matrix.h"
+#include "vertex.h"
+#include "light.h"
+#include "primitives.h"
+#include "texture.h"
+#include "BufferObjectManager.h"
+
+// ----------------------------------------------------------------------------
+
+#define VC_CACHE_STATISTICS 0
+#define VC_CACHE_TYPE_NONE 0
+#define VC_CACHE_TYPE_INDEXED 1
+#define VC_CACHE_TYPE_LRU 2
+#define VC_CACHE_TYPE VC_CACHE_TYPE_INDEXED
+
+#if VC_CACHE_STATISTICS
+#include <utils/Timers.h>
+#endif
+
+// ----------------------------------------------------------------------------
+
+namespace android {
+
+static void validate_arrays(ogles_context_t* c, GLenum mode);
+
+static void compileElements__generic(ogles_context_t*,
+ vertex_t*, GLint, GLsizei);
+static void compileElement__generic(ogles_context_t*,
+ vertex_t*, GLint);
+
+static void drawPrimitivesPoints(ogles_context_t*, GLint, GLsizei);
+static void drawPrimitivesLineStrip(ogles_context_t*, GLint, GLsizei);
+static void drawPrimitivesLineLoop(ogles_context_t*, GLint, GLsizei);
+static void drawPrimitivesLines(ogles_context_t*, GLint, GLsizei);
+static void drawPrimitivesTriangleStrip(ogles_context_t*, GLint, GLsizei);
+static void drawPrimitivesTriangleFan(ogles_context_t*, GLint, GLsizei);
+static void drawPrimitivesTriangles(ogles_context_t*, GLint, GLsizei);
+
+static void drawIndexedPrimitivesPoints(ogles_context_t*,
+ GLsizei, const GLvoid*);
+static void drawIndexedPrimitivesLineStrip(ogles_context_t*,
+ GLsizei, const GLvoid*);
+static void drawIndexedPrimitivesLineLoop(ogles_context_t*,
+ GLsizei, const GLvoid*);
+static void drawIndexedPrimitivesLines(ogles_context_t*,
+ GLsizei, const GLvoid*);
+static void drawIndexedPrimitivesTriangleStrip(ogles_context_t*,
+ GLsizei, const GLvoid*);
+static void drawIndexedPrimitivesTriangleFan(ogles_context_t*,
+ GLsizei, const GLvoid*);
+static void drawIndexedPrimitivesTriangles(ogles_context_t*,
+ GLsizei, const GLvoid*);
+
+// ----------------------------------------------------------------------------
+
+typedef void (*arrays_prims_fct_t)(ogles_context_t*, GLint, GLsizei);
+static const arrays_prims_fct_t drawArraysPrims[] = {
+ drawPrimitivesPoints,
+ drawPrimitivesLines,
+ drawPrimitivesLineLoop,
+ drawPrimitivesLineStrip,
+ drawPrimitivesTriangles,
+ drawPrimitivesTriangleStrip,
+ drawPrimitivesTriangleFan
+};
+
+typedef void (*elements_prims_fct_t)(ogles_context_t*, GLsizei, const GLvoid*);
+static const elements_prims_fct_t drawElementsPrims[] = {
+ drawIndexedPrimitivesPoints,
+ drawIndexedPrimitivesLines,
+ drawIndexedPrimitivesLineLoop,
+ drawIndexedPrimitivesLineStrip,
+ drawIndexedPrimitivesTriangles,
+ drawIndexedPrimitivesTriangleStrip,
+ drawIndexedPrimitivesTriangleFan
+};
+
+// ----------------------------------------------------------------------------
+#if 0
+#pragma mark -
+#endif
+
+void ogles_init_array(ogles_context_t* c)
+{
+ c->arrays.vertex.size = 4;
+ c->arrays.vertex.type = GL_FLOAT;
+ c->arrays.color.size = 4;
+ c->arrays.color.type = GL_FLOAT;
+ c->arrays.normal.size = 4;
+ c->arrays.normal.type = GL_FLOAT;
+ for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; i++) {
+ c->arrays.texture[i].size = 4;
+ c->arrays.texture[i].type = GL_FLOAT;
+ }
+ c->vc.init();
+
+ if (!c->vc.vBuffer) {
+ // this could have failed
+ ogles_error(c, GL_OUT_OF_MEMORY);
+ }
+}
+
+void ogles_uninit_array(ogles_context_t* c)
+{
+ c->vc.uninit();
+}
+
+// ----------------------------------------------------------------------------
+#if 0
+#pragma mark -
+#pragma mark Array fetchers
+#endif
+
+static void currentColor(ogles_context_t* c, GLfixed* v, const GLvoid*) {
+ memcpy(v, c->current.color.v, sizeof(vec4_t));
+}
+static void currentColor_clamp(ogles_context_t* c, GLfixed* v, const GLvoid*) {
+ memcpy(v, c->currentColorClamped.v, sizeof(vec4_t));
+}
+static void currentNormal(ogles_context_t* c, GLfixed* v, const GLvoid*) {
+ memcpy(v, c->currentNormal.v, sizeof(vec3_t));
+}
+static void currentTexCoord(ogles_context_t* c, GLfixed* v, const GLvoid*) {
+ memcpy(v, c->current.texture[c->arrays.tmu].v, sizeof(vec4_t));
+}
+
+
+static void fetchNop(ogles_context_t*, GLfixed*, const GLvoid*) {
+}
+static void fetch2b(ogles_context_t*, GLfixed* v, const GLbyte* p) {
+ v[0] = gglIntToFixed(p[0]);
+ v[1] = gglIntToFixed(p[1]);
+}
+static void fetch2s(ogles_context_t*, GLfixed* v, const GLshort* p) {
+ v[0] = gglIntToFixed(p[0]);
+ v[1] = gglIntToFixed(p[1]);
+}
+static void fetch2x(ogles_context_t*, GLfixed* v, const GLfixed* p) {
+ memcpy(v, p, 2*sizeof(GLfixed));
+}
+static void fetch2f(ogles_context_t*, GLfixed* v, const GLfloat* p) {
+ v[0] = gglFloatToFixed(p[0]);
+ v[1] = gglFloatToFixed(p[1]);
+}
+static void fetch3b(ogles_context_t*, GLfixed* v, const GLbyte* p) {
+ v[0] = gglIntToFixed(p[0]);
+ v[1] = gglIntToFixed(p[1]);
+ v[2] = gglIntToFixed(p[2]);
+}
+static void fetch3s(ogles_context_t*, GLfixed* v, const GLshort* p) {
+ v[0] = gglIntToFixed(p[0]);
+ v[1] = gglIntToFixed(p[1]);
+ v[2] = gglIntToFixed(p[2]);
+}
+static void fetch3x(ogles_context_t*, GLfixed* v, const GLfixed* p) {
+ memcpy(v, p, 3*sizeof(GLfixed));
+}
+static void fetch3f(ogles_context_t*, GLfixed* v, const GLfloat* p) {
+ v[0] = gglFloatToFixed(p[0]);
+ v[1] = gglFloatToFixed(p[1]);
+ v[2] = gglFloatToFixed(p[2]);
+}
+static void fetch4b(ogles_context_t*, GLfixed* v, const GLbyte* p) {
+ v[0] = gglIntToFixed(p[0]);
+ v[1] = gglIntToFixed(p[1]);
+ v[2] = gglIntToFixed(p[2]);
+ v[3] = gglIntToFixed(p[3]);
+}
+static void fetch4s(ogles_context_t*, GLfixed* v, const GLshort* p) {
+ v[0] = gglIntToFixed(p[0]);
+ v[1] = gglIntToFixed(p[1]);
+ v[2] = gglIntToFixed(p[2]);
+ v[3] = gglIntToFixed(p[3]);
+}
+static void fetch4x(ogles_context_t*, GLfixed* v, const GLfixed* p) {
+ memcpy(v, p, 4*sizeof(GLfixed));
+}
+static void fetch4f(ogles_context_t*, GLfixed* v, const GLfloat* p) {
+ v[0] = gglFloatToFixed(p[0]);
+ v[1] = gglFloatToFixed(p[1]);
+ v[2] = gglFloatToFixed(p[2]);
+ v[3] = gglFloatToFixed(p[3]);
+}
+static void fetchExpand4ub(ogles_context_t*, GLfixed* v, const GLubyte* p) {
+ v[0] = GGL_UB_TO_X(p[0]);
+ v[1] = GGL_UB_TO_X(p[1]);
+ v[2] = GGL_UB_TO_X(p[2]);
+ v[3] = GGL_UB_TO_X(p[3]);
+}
+static void fetchClamp4x(ogles_context_t*, GLfixed* v, const GLfixed* p) {
+ v[0] = gglClampx(p[0]);
+ v[1] = gglClampx(p[1]);
+ v[2] = gglClampx(p[2]);
+ v[3] = gglClampx(p[3]);
+}
+static void fetchClamp4f(ogles_context_t*, GLfixed* v, const GLfloat* p) {
+ v[0] = gglClampx(gglFloatToFixed(p[0]));
+ v[1] = gglClampx(gglFloatToFixed(p[1]));
+ v[2] = gglClampx(gglFloatToFixed(p[2]));
+ v[3] = gglClampx(gglFloatToFixed(p[3]));
+}
+static void fetchExpand3ub(ogles_context_t*, GLfixed* v, const GLubyte* p) {
+ v[0] = GGL_UB_TO_X(p[0]);
+ v[1] = GGL_UB_TO_X(p[1]);
+ v[2] = GGL_UB_TO_X(p[2]);
+ v[3] = 0x10000;
+}
+static void fetchClamp3x(ogles_context_t*, GLfixed* v, const GLfixed* p) {
+ v[0] = gglClampx(p[0]);
+ v[1] = gglClampx(p[1]);
+ v[2] = gglClampx(p[2]);
+ v[3] = 0x10000;
+}
+static void fetchClamp3f(ogles_context_t*, GLfixed* v, const GLfloat* p) {
+ v[0] = gglClampx(gglFloatToFixed(p[0]));
+ v[1] = gglClampx(gglFloatToFixed(p[1]));
+ v[2] = gglClampx(gglFloatToFixed(p[2]));
+ v[3] = 0x10000;
+}
+static void fetchExpand3b(ogles_context_t*, GLfixed* v, const GLbyte* p) {
+ v[0] = GGL_B_TO_X(p[0]);
+ v[1] = GGL_B_TO_X(p[1]);
+ v[2] = GGL_B_TO_X(p[2]);
+}
+static void fetchExpand3s(ogles_context_t*, GLfixed* v, const GLshort* p) {
+ v[0] = GGL_S_TO_X(p[0]);
+ v[1] = GGL_S_TO_X(p[1]);
+ v[2] = GGL_S_TO_X(p[2]);
+}
+
+typedef array_t::fetcher_t fn_t;
+
+static const fn_t color_fct[2][16] = { // size={3,4}, type={ub,f,x}
+ { 0, (fn_t)fetchExpand3ub, 0, 0, 0, 0,
+ (fn_t)fetch3f, 0, 0, 0, 0, 0,
+ (fn_t)fetch3x },
+ { 0, (fn_t)fetchExpand4ub, 0, 0, 0, 0,
+ (fn_t)fetch4f, 0, 0, 0, 0, 0,
+ (fn_t)fetch4x },
+};
+static const fn_t color_clamp_fct[2][16] = { // size={3,4}, type={ub,f,x}
+ { 0, (fn_t)fetchExpand3ub, 0, 0, 0, 0,
+ (fn_t)fetchClamp3f, 0, 0, 0, 0, 0,
+ (fn_t)fetchClamp3x },
+ { 0, (fn_t)fetchExpand4ub, 0, 0, 0, 0,
+ (fn_t)fetchClamp4f, 0, 0, 0, 0, 0,
+ (fn_t)fetchClamp4x },
+};
+static const fn_t normal_fct[1][16] = { // size={3}, type={b,s,f,x}
+ { (fn_t)fetchExpand3b, 0,
+ (fn_t)fetchExpand3s, 0, 0, 0,
+ (fn_t)fetch3f, 0, 0, 0, 0, 0,
+ (fn_t)fetch3x },
+};
+static const fn_t vertex_fct[3][16] = { // size={2,3,4}, type={b,s,f,x}
+ { (fn_t)fetch2b, 0,
+ (fn_t)fetch2s, 0, 0, 0,
+ (fn_t)fetch2f, 0, 0, 0, 0, 0,
+ (fn_t)fetch3x },
+ { (fn_t)fetch3b, 0,
+ (fn_t)fetch3s, 0, 0, 0,
+ (fn_t)fetch3f, 0, 0, 0, 0, 0,
+ (fn_t)fetch3x },
+ { (fn_t)fetch4b, 0,
+ (fn_t)fetch4s, 0, 0, 0,
+ (fn_t)fetch4f, 0, 0, 0, 0, 0,
+ (fn_t)fetch4x }
+};
+static const fn_t texture_fct[3][16] = { // size={2,3,4}, type={b,s,f,x}
+ { (fn_t)fetch2b, 0,
+ (fn_t)fetch2s, 0, 0, 0,
+ (fn_t)fetch2f, 0, 0, 0, 0, 0,
+ (fn_t)fetch2x },
+ { (fn_t)fetch3b, 0,
+ (fn_t)fetch3s, 0, 0, 0,
+ (fn_t)fetch3f, 0, 0, 0, 0, 0,
+ (fn_t)fetch3x },
+ { (fn_t)fetch4b, 0,
+ (fn_t)fetch4s, 0, 0, 0,
+ (fn_t)fetch4f, 0, 0, 0, 0, 0,
+ (fn_t)fetch4x }
+};
+
+// ----------------------------------------------------------------------------
+#if 0
+#pragma mark -
+#pragma mark array_t
+#endif
+
+void array_t::init(
+ GLint size, GLenum type, GLsizei stride,
+ const GLvoid *pointer, const buffer_t* bo, GLsizei count)
+{
+ if (!stride) {
+ stride = size;
+ switch (type) {
+ case GL_SHORT:
+ case GL_UNSIGNED_SHORT:
+ stride *= 2;
+ break;
+ case GL_FLOAT:
+ case GL_FIXED:
+ stride *= 4;
+ break;
+ }
+ }
+ this->size = size;
+ this->type = type;
+ this->stride = stride;
+ this->pointer = pointer;
+ this->bo = bo;
+ this->bounds = count;
+}
+
+inline void array_t::resolve()
+{
+ physical_pointer = (bo) ? (bo->data + uintptr_t(pointer)) : pointer;
+}
+
+// ----------------------------------------------------------------------------
+#if 0
+#pragma mark -
+#pragma mark vertex_cache_t
+#endif
+
+void vertex_cache_t::init()
+{
+ // make sure the size of vertex_t allows cache-line alignment
+ CTA<(sizeof(vertex_t) & 0x1F) == 0> assertAlignedSize;
+
+ const int align = 32;
+ const size_t s = VERTEX_BUFFER_SIZE + VERTEX_CACHE_SIZE;
+ const size_t size = s*sizeof(vertex_t) + align;
+ base = malloc(size);
+ if (base) {
+ memset(base, 0, size);
+ vBuffer = (vertex_t*)((size_t(base) + align - 1) & ~(align-1));
+ vCache = vBuffer + VERTEX_BUFFER_SIZE;
+ sequence = 0;
+ }
+}
+
+void vertex_cache_t::uninit()
+{
+ free(base);
+ base = vBuffer = vCache = 0;
+}
+
+void vertex_cache_t::clear()
+{
+#if VC_CACHE_STATISTICS
+ startTime = systemTime(SYSTEM_TIME_THREAD);
+ total = 0;
+ misses = 0;
+#endif
+
+#if VC_CACHE_TYPE == VC_CACHE_TYPE_LRU
+ vertex_t* v = vBuffer;
+ size_t count = VERTEX_BUFFER_SIZE + VERTEX_CACHE_SIZE;
+ do {
+ v->mru = 0;
+ v++;
+ } while (--count);
+#endif
+
+ sequence += INDEX_SEQ;
+ if (sequence >= 0x80000000LU) {
+ sequence = INDEX_SEQ;
+ vertex_t* v = vBuffer;
+ size_t count = VERTEX_BUFFER_SIZE + VERTEX_CACHE_SIZE;
+ do {
+ v->index = 0;
+ v++;
+ } while (--count);
+ }
+}
+
+void vertex_cache_t::dump_stats(GLenum mode)
+{
+#if VC_CACHE_STATISTICS
+ nsecs_t time = systemTime(SYSTEM_TIME_THREAD) - startTime;
+ uint32_t hits = total - misses;
+ uint32_t prim_count;
+ switch (mode) {
+ case GL_POINTS: prim_count = total; break;
+ case GL_LINE_STRIP: prim_count = total - 1; break;
+ case GL_LINE_LOOP: prim_count = total - 1; break;
+ case GL_LINES: prim_count = total / 2; break;
+ case GL_TRIANGLE_STRIP: prim_count = total - 2; break;
+ case GL_TRIANGLE_FAN: prim_count = total - 2; break;
+ case GL_TRIANGLES: prim_count = total / 3; break;
+ default: return;
+ }
+ printf( "total=%5u, hits=%5u, miss=%5u, hitrate=%3u%%,"
+ " prims=%5u, time=%6u us, prims/s=%d, v/t=%f\n",
+ total, hits, misses, (hits*100)/total,
+ prim_count, int(ns2us(time)), int(prim_count*float(seconds(1))/time),
+ float(misses) / prim_count);
+#endif
+}
+
+// ----------------------------------------------------------------------------
+#if 0
+#pragma mark -
+#endif
+
+static __attribute__((noinline))
+void enableDisableClientState(ogles_context_t* c, GLenum array, bool enable)
+{
+ const int tmu = c->arrays.activeTexture;
+ array_t* a;
+ switch (array) {
+ case GL_COLOR_ARRAY: a = &c->arrays.color; break;
+ case GL_NORMAL_ARRAY: a = &c->arrays.normal; break;
+ case GL_TEXTURE_COORD_ARRAY: a = &c->arrays.texture[tmu]; break;
+ case GL_VERTEX_ARRAY: a = &c->arrays.vertex; break;
+ default:
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ a->enable = enable ? GL_TRUE : GL_FALSE;
+}
+
+// ----------------------------------------------------------------------------
+#if 0
+#pragma mark -
+#pragma mark Vertex Cache
+#endif
+
+static __attribute__((noinline))
+vertex_t* cache_vertex(ogles_context_t* c, vertex_t* v, uint32_t index)
+{
+ #if VC_CACHE_STATISTICS
+ c->vc.misses++;
+ #endif
+ if (ggl_unlikely(v->locked)) {
+ // we're just looking for an entry in the cache that is not locked.
+ // and we know that there cannot be more than 2 locked entries
+ // because a triangle needs at most 3 vertices.
+ // We never use the first and second entries because they might be in
+ // use by the striper or faner. Any other entry will do as long as
+ // it's not locked.
+ // We compute directly the index of a "free" entry from the locked
+ // state of v[2] and v[3].
+ v = c->vc.vBuffer + 2;
+ v += v[0].locked | (v[1].locked<<1);
+ }
+ // note: compileElement clears v->flags
+ c->arrays.compileElement(c, v, index);
+ v->locked = 1;
+ return v;
+}
+
+static __attribute__((noinline))
+vertex_t* fetch_vertex(ogles_context_t* c, size_t index)
+{
+ index |= c->vc.sequence;
+
+#if VC_CACHE_TYPE == VC_CACHE_TYPE_INDEXED
+
+ vertex_t* const v = c->vc.vCache +
+ (index & (vertex_cache_t::VERTEX_CACHE_SIZE-1));
+
+ if (ggl_likely(v->index == index)) {
+ v->locked = 1;
+ return v;
+ }
+ return cache_vertex(c, v, index);
+
+#elif VC_CACHE_TYPE == VC_CACHE_TYPE_LRU
+
+ vertex_t* v = c->vc.vCache +
+ (index & ((vertex_cache_t::VERTEX_CACHE_SIZE-1)>>1))*2;
+
+ // always record LRU in v[0]
+ if (ggl_likely(v[0].index == index)) {
+ v[0].locked = 1;
+ v[0].mru = 0;
+ return &v[0];
+ }
+
+ if (ggl_likely(v[1].index == index)) {
+ v[1].locked = 1;
+ v[0].mru = 1;
+ return &v[1];
+ }
+
+ const int lru = 1 - v[0].mru;
+ v[0].mru = lru;
+ return cache_vertex(c, &v[lru], index);
+
+#elif VC_CACHE_TYPE == VC_CACHE_TYPE_NONE
+
+ // just for debugging...
+ vertex_t* v = c->vc.vBuffer + 2;
+ return cache_vertex(c, v, index);
+
+#endif
+}
+
+// ----------------------------------------------------------------------------
+#if 0
+#pragma mark -
+#pragma mark Primitive Assembly
+#endif
+
+void drawPrimitivesPoints(ogles_context_t* c, GLint first, GLsizei count)
+{
+ if (ggl_unlikely(count < 1))
+ return;
+
+ // vertex cache size must be multiple of 1
+ const GLsizei vcs =
+ (vertex_cache_t::VERTEX_BUFFER_SIZE +
+ vertex_cache_t::VERTEX_CACHE_SIZE);
+ do {
+ vertex_t* v = c->vc.vBuffer;
+ GLsizei num = count > vcs ? vcs : count;
+ c->arrays.cull = vertex_t::CLIP_ALL;
+ c->arrays.compileElements(c, v, first, num);
+ first += num;
+ count -= num;
+ if (!c->arrays.cull) {
+ // quick/trivial reject of the whole batch
+ do {
+ const uint32_t cc = v[0].flags;
+ if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
+ c->prims.renderPoint(c, v);
+ v++;
+ num--;
+ } while (num);
+ }
+ } while (count);
+}
+
+// ----------------------------------------------------------------------------
+
+void drawPrimitivesLineStrip(ogles_context_t* c, GLint first, GLsizei count)
+{
+ if (ggl_unlikely(count < 2))
+ return;
+
+ vertex_t *v, *v0, *v1;
+ c->arrays.cull = vertex_t::CLIP_ALL;
+ c->arrays.compileElement(c, c->vc.vBuffer, first);
+ first += 1;
+ count -= 1;
+
+ // vertex cache size must be multiple of 1
+ const GLsizei vcs =
+ (vertex_cache_t::VERTEX_BUFFER_SIZE +
+ vertex_cache_t::VERTEX_CACHE_SIZE - 1);
+ do {
+ v0 = c->vc.vBuffer + 0;
+ v = c->vc.vBuffer + 1;
+ GLsizei num = count > vcs ? vcs : count;
+ c->arrays.compileElements(c, v, first, num);
+ first += num;
+ count -= num;
+ if (!c->arrays.cull) {
+ // quick/trivial reject of the whole batch
+ do {
+ v1 = v++;
+ const uint32_t cc = v0->flags & v1->flags;
+ if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
+ c->prims.renderLine(c, v0, v1);
+ v0 = v1;
+ num--;
+ } while (num);
+ }
+ // copy back the last processed vertex
+ c->vc.vBuffer[0] = *v0;
+ c->arrays.cull = v0->flags & vertex_t::CLIP_ALL;
+ } while (count);
+}
+
+void drawPrimitivesLineLoop(ogles_context_t* c, GLint first, GLsizei count)
+{
+ if (ggl_unlikely(count < 2))
+ return;
+ drawPrimitivesLineStrip(c, first, count);
+ if (ggl_likely(count >= 3)) {
+ vertex_t* v0 = c->vc.vBuffer;
+ vertex_t* v1 = c->vc.vBuffer + 1;
+ c->arrays.compileElement(c, v1, first);
+ const uint32_t cc = v0->flags & v1->flags;
+ if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
+ c->prims.renderLine(c, v0, v1);
+ }
+}
+
+void drawPrimitivesLines(ogles_context_t* c, GLint first, GLsizei count)
+{
+ if (ggl_unlikely(count < 2))
+ return;
+
+ // vertex cache size must be multiple of 2
+ const GLsizei vcs =
+ ((vertex_cache_t::VERTEX_BUFFER_SIZE +
+ vertex_cache_t::VERTEX_CACHE_SIZE) / 2) * 2;
+ do {
+ vertex_t* v = c->vc.vBuffer;
+ GLsizei num = count > vcs ? vcs : count;
+ c->arrays.cull = vertex_t::CLIP_ALL;
+ c->arrays.compileElements(c, v, first, num);
+ first += num;
+ count -= num;
+ if (!c->arrays.cull) {
+ // quick/trivial reject of the whole batch
+ num -= 2;
+ do {
+ const uint32_t cc = v[0].flags & v[1].flags;
+ if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
+ c->prims.renderLine(c, v, v+1);
+ v += 2;
+ num -= 2;
+ } while (num >= 0);
+ }
+ } while (count >= 2);
+}
+
+// ----------------------------------------------------------------------------
+
+static void drawPrimitivesTriangleFanOrStrip(ogles_context_t* c,
+ GLint first, GLsizei count, int winding)
+{
+ // winding == 2 : fan
+ // winding == 1 : strip
+
+ if (ggl_unlikely(count < 3))
+ return;
+
+ vertex_t *v, *v0, *v1, *v2;
+ c->arrays.cull = vertex_t::CLIP_ALL;
+ c->arrays.compileElements(c, c->vc.vBuffer, first, 2);
+ first += 2;
+ count -= 2;
+
+ // vertex cache size must be multiple of 2. This is extremely important
+ // because it allows us to preserve the same winding when the whole
+ // batch is culled. We also need 2 extra vertices in the array, because
+ // we always keep the two first ones.
+ const GLsizei vcs =
+ ((vertex_cache_t::VERTEX_BUFFER_SIZE +
+ vertex_cache_t::VERTEX_CACHE_SIZE - 2) / 2) * 2;
+ do {
+ v0 = c->vc.vBuffer + 0;
+ v1 = c->vc.vBuffer + 1;
+ v = c->vc.vBuffer + 2;
+ GLsizei num = count > vcs ? vcs : count;
+ c->arrays.compileElements(c, v, first, num);
+ first += num;
+ count -= num;
+ if (!c->arrays.cull) {
+ // quick/trivial reject of the whole batch
+ do {
+ v2 = v++;
+ const uint32_t cc = v0->flags & v1->flags & v2->flags;
+ if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
+ c->prims.renderTriangle(c, v0, v1, v2);
+ swap(((winding^=1) ? v1 : v0), v2);
+ num--;
+ } while (num);
+ }
+ if (count) {
+ v0 = c->vc.vBuffer + 2 + num - 2;
+ v1 = c->vc.vBuffer + 2 + num - 1;
+ if ((winding&2) == 0) {
+ // for strips copy back the two last compiled vertices
+ c->vc.vBuffer[0] = *v0;
+ }
+ c->vc.vBuffer[1] = *v1;
+ c->arrays.cull = v0->flags & v1->flags & vertex_t::CLIP_ALL;
+ }
+ } while (count > 0);
+}
+
+void drawPrimitivesTriangleStrip(ogles_context_t* c,
+ GLint first, GLsizei count) {
+ drawPrimitivesTriangleFanOrStrip(c, first, count, 1);
+}
+
+void drawPrimitivesTriangleFan(ogles_context_t* c,
+ GLint first, GLsizei count) {
+ drawPrimitivesTriangleFanOrStrip(c, first, count, 2);
+}
+
+void drawPrimitivesTriangles(ogles_context_t* c, GLint first, GLsizei count)
+{
+ if (ggl_unlikely(count < 3))
+ return;
+
+ // vertex cache size must be multiple of 3
+ const GLsizei vcs =
+ ((vertex_cache_t::VERTEX_BUFFER_SIZE +
+ vertex_cache_t::VERTEX_CACHE_SIZE) / 3) * 3;
+ do {
+ vertex_t* v = c->vc.vBuffer;
+ GLsizei num = count > vcs ? vcs : count;
+ c->arrays.cull = vertex_t::CLIP_ALL;
+ c->arrays.compileElements(c, v, first, num);
+ first += num;
+ count -= num;
+ if (!c->arrays.cull) {
+ // quick/trivial reject of the whole batch
+ num -= 3;
+ do {
+ const uint32_t cc = v[0].flags & v[1].flags & v[2].flags;
+ if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
+ c->prims.renderTriangle(c, v, v+1, v+2);
+ v += 3;
+ num -= 3;
+ } while (num >= 0);
+ }
+ } while (count >= 3);
+}
+
+// ----------------------------------------------------------------------------
+#if 0
+#pragma mark -
+#endif
+
+// this looks goofy, but gcc does a great job with this...
+static inline unsigned int read_index(int type, const GLvoid*& p) {
+ unsigned int r;
+ if (type) {
+ r = *(const GLubyte*)p;
+ p = (const GLubyte*)p + 1;
+ } else {
+ r = *(const GLushort*)p;
+ p = (const GLushort*)p + 1;
+ }
+ return r;
+}
+
+// ----------------------------------------------------------------------------
+
+void drawIndexedPrimitivesPoints(ogles_context_t* c,
+ GLsizei count, const GLvoid *indices)
+{
+ if (ggl_unlikely(count < 1))
+ return;
+ const int type = (c->arrays.indicesType == GL_UNSIGNED_BYTE);
+ do {
+ vertex_t * v = fetch_vertex(c, read_index(type, indices));
+ if (ggl_likely(!(v->flags & vertex_t::CLIP_ALL)))
+ c->prims.renderPoint(c, v);
+ v->locked = 0;
+ count--;
+ } while(count);
+}
+
+// ----------------------------------------------------------------------------
+
+void drawIndexedPrimitivesLineStrip(ogles_context_t* c,
+ GLsizei count, const GLvoid *indices)
+{
+ if (ggl_unlikely(count < 2))
+ return;
+
+ vertex_t * const v = c->vc.vBuffer;
+ vertex_t* v0 = v;
+ vertex_t* v1;
+
+ const int type = (c->arrays.indicesType == GL_UNSIGNED_BYTE);
+ c->arrays.compileElement(c, v0, read_index(type, indices));
+ count -= 1;
+ do {
+ v1 = fetch_vertex(c, read_index(type, indices));
+ const uint32_t cc = v0->flags & v1->flags;
+ if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
+ c->prims.renderLine(c, v0, v1);
+ v0->locked = 0;
+ v0 = v1;
+ count--;
+ } while (count);
+ v1->locked = 0;
+}
+
+void drawIndexedPrimitivesLineLoop(ogles_context_t* c,
+ GLsizei count, const GLvoid *indices)
+{
+ if (ggl_unlikely(count <= 2)) {
+ drawIndexedPrimitivesLines(c, count, indices);
+ return;
+ }
+
+ vertex_t * const v = c->vc.vBuffer;
+ vertex_t* v0 = v;
+ vertex_t* v1;
+
+ const int type = (c->arrays.indicesType == GL_UNSIGNED_BYTE);
+ c->arrays.compileElement(c, v0, read_index(type, indices));
+ count -= 1;
+ do {
+ v1 = fetch_vertex(c, read_index(type, indices));
+ const uint32_t cc = v0->flags & v1->flags;
+ if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
+ c->prims.renderLine(c, v0, v1);
+ v0->locked = 0;
+ v0 = v1;
+ count--;
+ } while (count);
+ v1->locked = 0;
+
+ v1 = c->vc.vBuffer;
+ const uint32_t cc = v0->flags & v1->flags;
+ if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
+ c->prims.renderLine(c, v0, v1);
+}
+
+void drawIndexedPrimitivesLines(ogles_context_t* c,
+ GLsizei count, const GLvoid *indices)
+{
+ if (ggl_unlikely(count < 2))
+ return;
+
+ count -= 2;
+ const int type = (c->arrays.indicesType == GL_UNSIGNED_BYTE);
+ do {
+ vertex_t* const v0 = fetch_vertex(c, read_index(type, indices));
+ vertex_t* const v1 = fetch_vertex(c, read_index(type, indices));
+ const uint32_t cc = v0->flags & v1->flags;
+ if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
+ c->prims.renderLine(c, v0, v1);
+ v0->locked = 0;
+ v1->locked = 0;
+ count -= 2;
+ } while (count >= 0);
+}
+
+// ----------------------------------------------------------------------------
+
+static void drawIndexedPrimitivesTriangleFanOrStrip(ogles_context_t* c,
+ GLsizei count, const GLvoid *indices, int winding)
+{
+ // winding == 2 : fan
+ // winding == 1 : strip
+
+ if (ggl_unlikely(count < 3))
+ return;
+
+ vertex_t * const v = c->vc.vBuffer;
+ vertex_t* v0 = v;
+ vertex_t* v1 = v+1;
+ vertex_t* v2;
+
+ const int type = (c->arrays.indicesType == GL_UNSIGNED_BYTE);
+ c->arrays.compileElement(c, v0, read_index(type, indices));
+ c->arrays.compileElement(c, v1, read_index(type, indices));
+ count -= 2;
+
+ // note: GCC 4.1.1 here makes a prety interesting optimization
+ // where it duplicates the loop below based on c->arrays.indicesType
+
+ do {
+ v2 = fetch_vertex(c, read_index(type, indices));
+ const uint32_t cc = v0->flags & v1->flags & v2->flags;
+ if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
+ c->prims.renderTriangle(c, v0, v1, v2);
+ vertex_t* & consumed = ((winding^=1) ? v1 : v0);
+ consumed->locked = 0;
+ consumed = v2;
+ count--;
+ } while (count);
+ v0->locked = v1->locked = 0;
+ v2->locked = 0;
+}
+
+void drawIndexedPrimitivesTriangleStrip(ogles_context_t* c,
+ GLsizei count, const GLvoid *indices) {
+ drawIndexedPrimitivesTriangleFanOrStrip(c, count, indices, 1);
+}
+
+void drawIndexedPrimitivesTriangleFan(ogles_context_t* c,
+ GLsizei count, const GLvoid *indices) {
+ drawIndexedPrimitivesTriangleFanOrStrip(c, count, indices, 2);
+}
+
+void drawIndexedPrimitivesTriangles(ogles_context_t* c,
+ GLsizei count, const GLvoid *indices)
+{
+ if (ggl_unlikely(count < 3))
+ return;
+
+ count -= 3;
+ if (ggl_likely(c->arrays.indicesType == GL_UNSIGNED_SHORT)) {
+ // This case is probably our most common case...
+ uint16_t const * p = (uint16_t const *)indices;
+ do {
+ vertex_t* const v0 = fetch_vertex(c, *p++);
+ vertex_t* const v1 = fetch_vertex(c, *p++);
+ vertex_t* const v2 = fetch_vertex(c, *p++);
+ const uint32_t cc = v0->flags & v1->flags & v2->flags;
+ if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
+ c->prims.renderTriangle(c, v0, v1, v2);
+ v0->locked = 0;
+ v1->locked = 0;
+ v2->locked = 0;
+ count -= 3;
+ } while (count >= 0);
+ } else {
+ uint8_t const * p = (uint8_t const *)indices;
+ do {
+ vertex_t* const v0 = fetch_vertex(c, *p++);
+ vertex_t* const v1 = fetch_vertex(c, *p++);
+ vertex_t* const v2 = fetch_vertex(c, *p++);
+ const uint32_t cc = v0->flags & v1->flags & v2->flags;
+ if (ggl_likely(!(cc & vertex_t::CLIP_ALL)))
+ c->prims.renderTriangle(c, v0, v1, v2);
+ v0->locked = 0;
+ v1->locked = 0;
+ v2->locked = 0;
+ count -= 3;
+ } while (count >= 0);
+ }
+}
+
+// ----------------------------------------------------------------------------
+#if 0
+#pragma mark -
+#pragma mark Array compilers
+#endif
+
+void compileElement__generic(ogles_context_t* c,
+ vertex_t* v, GLint first)
+{
+ v->flags = 0;
+ v->index = first;
+ first &= vertex_cache_t::INDEX_MASK;
+ const GLubyte* vp = c->arrays.vertex.element(first);
+ c->arrays.vertex.fetch(c, v->obj.v, vp);
+ c->arrays.mvp_transform(&c->transforms.mvp, &v->clip, &v->obj);
+ c->arrays.perspective(c, v);
+}
+
+void compileElements__generic(ogles_context_t* c,
+ vertex_t* v, GLint first, GLsizei count)
+{
+ const GLubyte* vp = c->arrays.vertex.element(
+ first & vertex_cache_t::INDEX_MASK);
+ const size_t stride = c->arrays.vertex.stride;
+ transform_t const* const mvp = &c->transforms.mvp;
+ do {
+ v->flags = 0;
+ v->index = first++;
+ c->arrays.vertex.fetch(c, v->obj.v, vp);
+ c->arrays.mvp_transform(mvp, &v->clip, &v->obj);
+ c->arrays.perspective(c, v);
+ vp += stride;
+ v++;
+ } while (--count);
+}
+
+/*
+void compileElements__3x_full(ogles_context_t* c,
+ vertex_t* v, GLint first, GLsizei count)
+{
+ const GLfixed* vp = (const GLfixed*)c->arrays.vertex.element(first);
+ const size_t stride = c->arrays.vertex.stride / 4;
+// const GLfixed* const& m = c->transforms.mvp.matrix.m;
+
+ GLfixed m[16];
+ memcpy(&m, c->transforms.mvp.matrix.m, sizeof(m));
+
+ do {
+ const GLfixed rx = vp[0];
+ const GLfixed ry = vp[1];
+ const GLfixed rz = vp[2];
+ vp += stride;
+ v->index = first++;
+ v->clip.x = mla3a(rx, m[ 0], ry, m[ 4], rz, m[ 8], m[12]);
+ v->clip.y = mla3a(rx, m[ 1], ry, m[ 5], rz, m[ 9], m[13]);
+ v->clip.z = mla3a(rx, m[ 2], ry, m[ 6], rz, m[10], m[14]);
+ v->clip.w = mla3a(rx, m[ 3], ry, m[ 7], rz, m[11], m[15]);
+
+ const GLfixed w = v->clip.w;
+ uint32_t clip = 0;
+ if (v->clip.x < -w) clip |= vertex_t::CLIP_L;
+ if (v->clip.x > w) clip |= vertex_t::CLIP_R;
+ if (v->clip.y < -w) clip |= vertex_t::CLIP_B;
+ if (v->clip.y > w) clip |= vertex_t::CLIP_T;
+ if (v->clip.z < -w) clip |= vertex_t::CLIP_N;
+ if (v->clip.z > w) clip |= vertex_t::CLIP_F;
+ v->flags = clip;
+ c->arrays.cull &= clip;
+
+ //c->arrays.perspective(c, v);
+ v++;
+ } while (--count);
+}
+*/
+
+// ----------------------------------------------------------------------------
+#if 0
+#pragma mark -
+#pragma mark clippers
+#endif
+
+static void clipVec4(vec4_t& nv,
+ GLfixed t, const vec4_t& s, const vec4_t& p)
+{
+ for (int i=0; i<4 ; i++)
+ nv.v[i] = gglMulAddx(t, s.v[i] - p.v[i], p.v[i], 28);
+}
+
+static void clipVertex(ogles_context_t* c, vertex_t* nv,
+ GLfixed t, const vertex_t* s, const vertex_t* p)
+{
+ clipVec4(nv->clip, t, s->clip, p->clip);
+ nv->fog = gglMulAddx(t, s->fog - p->fog, p->fog, 28);
+ ogles_vertex_project(c, nv);
+ nv->flags |= vertex_t::LIT | vertex_t::EYE | vertex_t::TT;
+ nv->flags &= ~vertex_t::CLIP_ALL;
+}
+
+static void clipVertexC(ogles_context_t* c, vertex_t* nv,
+ GLfixed t, const vertex_t* s, const vertex_t* p)
+{
+ clipVec4(nv->color, t, s->color, p->color);
+ clipVertex(c, nv, t, s, p);
+}
+
+static void clipVertexT(ogles_context_t* c, vertex_t* nv,
+ GLfixed t, const vertex_t* s, const vertex_t* p)
+{
+ for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; i++) {
+ if (c->rasterizer.state.texture[i].enable)
+ clipVec4(nv->texture[i], t, s->texture[i], p->texture[i]);
+ }
+ clipVertex(c, nv, t, s, p);
+}
+
+static void clipVertexAll(ogles_context_t* c, vertex_t* nv,
+ GLfixed t, const vertex_t* s, const vertex_t* p)
+{
+ clipVec4(nv->color, t, s->color, p->color);
+ clipVertexT(c, nv, t, s, p);
+}
+
+static void clipEye(ogles_context_t* c, vertex_t* nv,
+ GLfixed t, const vertex_t* s, const vertex_t* p)
+{
+ nv->clear();
+ c->arrays.clipVertex(c, nv, t, p, s);
+ clipVec4(nv->eye, t, s->eye, p->eye);
+}
+
+// ----------------------------------------------------------------------------
+#if 0
+#pragma mark -
+#endif
+
+void validate_arrays(ogles_context_t* c, GLenum mode)
+{
+ uint32_t enables = c->rasterizer.state.enables;
+
+ // Perspective correction is not need if Ortho transform, but
+ // the user can still provide the w coordinate manually, so we can't
+ // automatically turn it off (in fact we could when the 4th coordinate
+ // is not spcified in the vertex array).
+ // W interpolation is never needed for points.
+ GLboolean perspective =
+ c->perspective && mode!=GL_POINTS && (enables & GGL_ENABLE_TMUS);
+ c->rasterizer.procs.enableDisable(c, GGL_W_LERP, perspective);
+
+ // set anti-aliasing
+ GLboolean smooth = GL_FALSE;
+ switch (mode) {
+ case GL_POINTS:
+ smooth = c->point.smooth;
+ break;
+ case GL_LINES:
+ case GL_LINE_LOOP:
+ case GL_LINE_STRIP:
+ smooth = c->line.smooth;
+ break;
+ }
+ if (((enables & GGL_ENABLE_AA)?1:0) != smooth)
+ c->rasterizer.procs.enableDisable(c, GGL_AA, smooth);
+
+ // set the shade model for this primitive
+ c->rasterizer.procs.shadeModel(c,
+ (mode == GL_POINTS) ? GL_FLAT : c->lighting.shadeModel);
+
+ // compute all the matrices we'll need...
+ uint32_t want =
+ transform_state_t::MVP |
+ transform_state_t::VIEWPORT;
+ if (c->lighting.enable) { // needs normal transforms and eye coords
+ want |= transform_state_t::MVUI;
+ want |= transform_state_t::MODELVIEW;
+ }
+ if (enables & GGL_ENABLE_TMUS) { // needs texture transforms
+ want |= transform_state_t::TEXTURE;
+ }
+ if (c->clipPlanes.enable || (enables & GGL_ENABLE_FOG)) {
+ want |= transform_state_t::MODELVIEW; // needs eye coords
+ }
+ ogles_validate_transform(c, want);
+
+ // textures...
+ if (enables & GGL_ENABLE_TMUS)
+ ogles_validate_texture(c);
+
+ // vertex compilers
+ c->arrays.compileElement = compileElement__generic;
+ c->arrays.compileElements = compileElements__generic;
+
+ // vertex transform
+ c->arrays.mvp_transform =
+ c->transforms.mvp.pointv[c->arrays.vertex.size - 2];
+
+ c->arrays.mv_transform =
+ c->transforms.modelview.transform.pointv[c->arrays.vertex.size - 2];
+
+ /*
+ * ***********************************************************************
+ * pick fetchers
+ * ***********************************************************************
+ */
+
+ array_machine_t& am = c->arrays;
+ am.vertex.fetch = fetchNop;
+ am.normal.fetch = currentNormal;
+ am.color.fetch = currentColor;
+
+ if (am.vertex.enable) {
+ am.vertex.resolve();
+ if (am.vertex.bo || am.vertex.pointer) {
+ am.vertex.fetch = vertex_fct[am.vertex.size-2][am.vertex.type & 0xF];
+ }
+ }
+
+ if (am.normal.enable) {
+ am.normal.resolve();
+ if (am.normal.bo || am.normal.pointer) {
+ am.normal.fetch = normal_fct[am.normal.size-3][am.normal.type & 0xF];
+ }
+ }
+
+ if (am.color.enable) {
+ am.color.resolve();
+ if (c->lighting.enable) {
+ if (am.color.bo || am.color.pointer) {
+ am.color.fetch = color_fct[am.color.size-3][am.color.type & 0xF];
+ }
+ } else {
+ if (am.color.bo || am.color.pointer) {
+ am.color.fetch = color_clamp_fct[am.color.size-3][am.color.type & 0xF];
+ }
+ }
+ }
+
+ int activeTmuCount = 0;
+ for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; i++) {
+ am.texture[i].fetch = currentTexCoord;
+ if (c->rasterizer.state.texture[i].enable) {
+
+ // texture fetchers...
+ if (am.texture[i].enable) {
+ am.texture[i].resolve();
+ if (am.texture[i].bo || am.texture[i].pointer) {
+ am.texture[i].fetch = texture_fct[am.texture[i].size-2][am.texture[i].type & 0xF];
+ }
+ }
+
+ // texture transform...
+ const int index = c->arrays.texture[i].size - 2;
+ c->arrays.tex_transform[i] =
+ c->transforms.texture[i].transform.pointv[index];
+
+ am.tmu = i;
+ activeTmuCount++;
+ }
+ }
+
+ // pick the vertex-clipper
+ uint32_t clipper = 0;
+ // we must reload 'enables' here
+ enables = c->rasterizer.state.enables;
+ if (enables & GGL_ENABLE_SMOOTH)
+ clipper |= 1; // we need to interpolate colors
+ if (enables & GGL_ENABLE_TMUS)
+ clipper |= 2; // we need to interpolate textures
+ switch (clipper) {
+ case 0: c->arrays.clipVertex = clipVertex; break;
+ case 1: c->arrays.clipVertex = clipVertexC; break;
+ case 2: c->arrays.clipVertex = clipVertexT; break;
+ case 3: c->arrays.clipVertex = clipVertexAll; break;
+ }
+ c->arrays.clipEye = clipEye;
+
+ // pick the primitive rasterizer
+ ogles_validate_primitives(c);
+}
+
+// ----------------------------------------------------------------------------
+}; // namespace android
+// ----------------------------------------------------------------------------
+
+using namespace android;
+
+#if 0
+#pragma mark -
+#pragma mark array API
+#endif
+
+void glVertexPointer(
+ GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if (size<2 || size>4 || stride<0) {
+ ogles_error(c, GL_INVALID_VALUE);
+ return;
+ }
+ switch (type) {
+ case GL_BYTE:
+ case GL_SHORT:
+ case GL_FIXED:
+ case GL_FLOAT:
+ break;
+ default:
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ c->arrays.vertex.init(size, type, stride, pointer, c->arrays.array_buffer, 0);
+}
+
+void glColorPointer(
+ GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ // in theory ogles doesn't allow color arrays of size 3
+ // but it is very useful to 'visualize' the normal array.
+ if (size<3 || size>4 || stride<0) {
+ ogles_error(c, GL_INVALID_VALUE);
+ return;
+ }
+ switch (type) {
+ case GL_UNSIGNED_BYTE:
+ case GL_FIXED:
+ case GL_FLOAT:
+ break;
+ default:
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ c->arrays.color.init(size, type, stride, pointer, c->arrays.array_buffer, 0);
+}
+
+void glNormalPointer(
+ GLenum type, GLsizei stride, const GLvoid *pointer)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if (stride<0) {
+ ogles_error(c, GL_INVALID_VALUE);
+ return;
+ }
+ switch (type) {
+ case GL_BYTE:
+ case GL_SHORT:
+ case GL_FIXED:
+ case GL_FLOAT:
+ break;
+ default:
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ c->arrays.normal.init(3, type, stride, pointer, c->arrays.array_buffer, 0);
+}
+
+void glTexCoordPointer(
+ GLint size, GLenum type, GLsizei stride, const GLvoid *pointer)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if (size<2 || size>4 || stride<0) {
+ ogles_error(c, GL_INVALID_VALUE);
+ return;
+ }
+ switch (type) {
+ case GL_BYTE:
+ case GL_SHORT:
+ case GL_FIXED:
+ case GL_FLOAT:
+ break;
+ default:
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ const int tmu = c->arrays.activeTexture;
+ c->arrays.texture[tmu].init(size, type, stride, pointer,
+ c->arrays.array_buffer, 0);
+}
+
+
+void glEnableClientState(GLenum array) {
+ ogles_context_t* c = ogles_context_t::get();
+ enableDisableClientState(c, array, true);
+}
+
+void glDisableClientState(GLenum array) {
+ ogles_context_t* c = ogles_context_t::get();
+ enableDisableClientState(c, array, false);
+}
+
+void glClientActiveTexture(GLenum texture)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if (texture<GL_TEXTURE0 || texture>=GL_TEXTURE0+GGL_TEXTURE_UNIT_COUNT) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ c->arrays.activeTexture = texture - GL_TEXTURE0;
+}
+
+void glDrawArrays(GLenum mode, GLint first, GLsizei count)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if (count<0) {
+ ogles_error(c, GL_INVALID_VALUE);
+ return;
+ }
+ switch (mode) {
+ case GL_POINTS:
+ case GL_LINE_STRIP:
+ case GL_LINE_LOOP:
+ case GL_LINES:
+ case GL_TRIANGLE_STRIP:
+ case GL_TRIANGLE_FAN:
+ case GL_TRIANGLES:
+ break;
+ default:
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+
+ if (count == 0 || !c->arrays.vertex.enable)
+ return;
+ if ((c->cull.enable) && (c->cull.cullFace == GL_FRONT_AND_BACK))
+ return; // all triangles are culled
+
+ validate_arrays(c, mode);
+ drawArraysPrims[mode](c, first, count);
+
+#if VC_CACHE_STATISTICS
+ c->vc.total = count;
+ c->vc.dump_stats(mode);
+#endif
+}
+
+void glDrawElements(
+ GLenum mode, GLsizei count, GLenum type, const GLvoid *indices)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if (count<0) {
+ ogles_error(c, GL_INVALID_VALUE);
+ return;
+ }
+ switch (mode) {
+ case GL_POINTS:
+ case GL_LINE_STRIP:
+ case GL_LINE_LOOP:
+ case GL_LINES:
+ case GL_TRIANGLE_STRIP:
+ case GL_TRIANGLE_FAN:
+ case GL_TRIANGLES:
+ break;
+ default:
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ switch (type) {
+ case GL_UNSIGNED_BYTE:
+ case GL_UNSIGNED_SHORT:
+ c->arrays.indicesType = type;
+ break;
+ default:
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ if (count == 0 || !c->arrays.vertex.enable)
+ return;
+ if ((c->cull.enable) && (c->cull.cullFace == GL_FRONT_AND_BACK))
+ return; // all triangles are culled
+
+ // clear the vertex-cache
+ c->vc.clear();
+ validate_arrays(c, mode);
+
+ // if indices are in a buffer object, the pointer is treated as an
+ // offset in that buffer.
+ if (c->arrays.element_array_buffer) {
+ indices = c->arrays.element_array_buffer->data + uintptr_t(indices);
+ }
+
+ drawElementsPrims[mode](c, count, indices);
+
+#if VC_CACHE_STATISTICS
+ c->vc.total = count;
+ c->vc.dump_stats(mode);
+#endif
+}
+
+// ----------------------------------------------------------------------------
+// buffers
+// ----------------------------------------------------------------------------
+
+void glBindBuffer(GLenum target, GLuint buffer)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if ((target!=GL_ARRAY_BUFFER) && (target!=GL_ELEMENT_ARRAY_BUFFER)) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ // create a buffer object, or bind an existing one
+ buffer_t const* bo = 0;
+ if (buffer) {
+ bo = c->bufferObjectManager->bind(buffer);
+ if (!bo) {
+ ogles_error(c, GL_OUT_OF_MEMORY);
+ return;
+ }
+ }
+ ((target == GL_ARRAY_BUFFER) ?
+ c->arrays.array_buffer : c->arrays.element_array_buffer) = bo;
+}
+
+void glBufferData(GLenum target, GLsizeiptr size, const GLvoid* data, GLenum usage)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if ((target!=GL_ARRAY_BUFFER) && (target!=GL_ELEMENT_ARRAY_BUFFER)) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ if (size<0) {
+ ogles_error(c, GL_INVALID_VALUE);
+ return;
+ }
+ if ((usage!=GL_STATIC_DRAW) && (usage!=GL_DYNAMIC_DRAW)) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ buffer_t const* bo = ((target == GL_ARRAY_BUFFER) ?
+ c->arrays.array_buffer : c->arrays.element_array_buffer);
+
+ if (bo == 0) {
+ // can't modify buffer 0
+ ogles_error(c, GL_INVALID_OPERATION);
+ return;
+ }
+
+ buffer_t* edit_bo = const_cast<buffer_t*>(bo);
+ if (c->bufferObjectManager->allocateStore(edit_bo, size, usage) != 0) {
+ ogles_error(c, GL_OUT_OF_MEMORY);
+ return;
+ }
+ if (data) {
+ memcpy(bo->data, data, size);
+ }
+}
+
+void glBufferSubData(GLenum target, GLintptr offset, GLsizeiptr size, const GLvoid* data)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if ((target!=GL_ARRAY_BUFFER) && (target!=GL_ELEMENT_ARRAY_BUFFER)) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ if (offset<0 || size<0 || data==0) {
+ ogles_error(c, GL_INVALID_VALUE);
+ return;
+ }
+ buffer_t const* bo = ((target == GL_ARRAY_BUFFER) ?
+ c->arrays.array_buffer : c->arrays.element_array_buffer);
+
+ if (bo == 0) {
+ // can't modify buffer 0
+ ogles_error(c, GL_INVALID_OPERATION);
+ return;
+ }
+ if (offset+size > bo->size) {
+ ogles_error(c, GL_INVALID_VALUE);
+ return;
+ }
+ memcpy(bo->data + offset, data, size);
+}
+
+void glDeleteBuffers(GLsizei n, const GLuint* buffers)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if (n<0) {
+ ogles_error(c, GL_INVALID_VALUE);
+ return;
+ }
+
+ for (int i=0 ; i<n ; i++) {
+ GLuint name = buffers[i];
+ if (name) {
+ // unbind bound deleted buffers...
+ if (c->arrays.element_array_buffer->name == name) {
+ c->arrays.element_array_buffer = 0;
+ }
+ if (c->arrays.array_buffer->name == name) {
+ c->arrays.array_buffer = 0;
+ }
+ if (c->arrays.vertex.bo->name == name) {
+ c->arrays.vertex.bo = 0;
+ }
+ if (c->arrays.normal.bo->name == name) {
+ c->arrays.normal.bo = 0;
+ }
+ if (c->arrays.color.bo->name == name) {
+ c->arrays.color.bo = 0;
+ }
+ for (int t=0 ; t<GGL_TEXTURE_UNIT_COUNT ; t++) {
+ if (c->arrays.texture[t].bo->name == name) {
+ c->arrays.texture[t].bo = 0;
+ }
+ }
+ }
+ }
+ c->bufferObjectManager->deleteBuffers(n, buffers);
+ c->bufferObjectManager->recycleTokens(n, buffers);
+}
+
+void glGenBuffers(GLsizei n, GLuint* buffers)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if (n<0) {
+ ogles_error(c, GL_INVALID_VALUE);
+ return;
+ }
+ c->bufferObjectManager->getToken(n, buffers);
+}
diff --git a/opengl/libagl/array.h b/opengl/libagl/array.h
new file mode 100644
index 0000000..e156978
--- /dev/null
+++ b/opengl/libagl/array.h
@@ -0,0 +1,37 @@
+/* libs/opengles/array.h
+**
+** Copyright 2006, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+** http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+#ifndef ANDROID_OPENGLES_ARRAY_H
+#define ANDROID_OPENGLES_ARRAY_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include <sys/types.h>
+
+namespace android {
+
+namespace gl {
+struct ogles_context_t;
+};
+
+void ogles_init_array(ogles_context_t* c);
+void ogles_uninit_array(ogles_context_t* c);
+
+}; // namespace android
+
+#endif // ANDROID_OPENGLES_ARRAY_H
+
diff --git a/opengl/libagl/context.h b/opengl/libagl/context.h
new file mode 100644
index 0000000..ef36b56
--- /dev/null
+++ b/opengl/libagl/context.h
@@ -0,0 +1,20 @@
+/* libs/opengles/context.h
+**
+** Copyright 2006, 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 <private/opengles/gl_context.h>
+
+using namespace android::gl;
diff --git a/opengl/libagl/dxt.cpp b/opengl/libagl/dxt.cpp
new file mode 100644
index 0000000..238c81f
--- /dev/null
+++ b/opengl/libagl/dxt.cpp
@@ -0,0 +1,636 @@
+/* libs/opengles/dxt.cpp
+**
+** 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.
+*/
+
+#define TIMING 0
+
+#if TIMING
+#include <sys/time.h> // for optimization timing
+#include <stdio.h>
+#include <stdlib.h>
+#endif
+
+#include <GLES/gl.h>
+#include <utils/Endian.h>
+
+#include "context.h"
+
+#define TIMING 0
+
+namespace android {
+
+static uint8_t avg23tab[64*64];
+static volatile int tables_initialized = 0;
+
+// Definitions below are equivalent to these over the valid range of arguments
+// #define div5(x) ((x)/5)
+// #define div7(x) ((x)/7)
+
+// Use fixed-point to divide by 5 and 7
+// 3277 = 2^14/5 + 1
+// 2341 = 2^14/7 + 1
+#define div5(x) (((x)*3277) >> 14)
+#define div7(x) (((x)*2341) >> 14)
+
+// Table with entry [a << 6 | b] = (2*a + b)/3 for 0 <= a,b < 64
+#define avg23(x0,x1) avg23tab[((x0) << 6) | (x1)]
+
+// Extract 5/6/5 RGB
+#define red(x) (((x) >> 11) & 0x1f)
+#define green(x) (((x) >> 5) & 0x3f)
+#define blue(x) ( (x) & 0x1f)
+
+/*
+ * Convert 5/6/5 RGB (as 3 ints) to 8/8/8
+ *
+ * Operation count: 8 <<, 0 &, 5 |
+ */
+inline static int rgb565SepTo888(int r, int g, int b)
+
+{
+ return ((((r << 3) | (r >> 2)) << 16) |
+ (((g << 2) | (g >> 4)) << 8) |
+ ((b << 3) | (b >> 2)));
+}
+
+/*
+ * Convert 5/6/5 RGB (as a single 16-bit word) to 8/8/8
+ *
+ * r4r3r2r1 r0g5g4g3 g2g1g0b4 b3b2b1b0 rgb
+ * r4r3r2 r1r0g5g4 g3g2g1g0 b4b3b2b1 b0 0 0 0 rgb << 3
+ * r4r3r2r1 r0r4r3r2 g5g4g3g2 g1g0g5g4 b4b3b2b1 b0b4b3b2 desired result
+ *
+ * Construct the 24-bit RGB word as:
+ *
+ * r4r3r2r1 r0------ -------- -------- -------- -------- (rgb << 8) & 0xf80000
+ * r4r3r2 -------- -------- -------- -------- (rgb << 3) & 0x070000
+ * g5g4g3g2 g1g0---- -------- -------- (rgb << 5) & 0x00fc00
+ * g5g4 -------- -------- (rgb >> 1) & 0x000300
+ * b4b3b2b1 b0------ (rgb << 3) & 0x0000f8
+ * b4b3b2 (rgb >> 2) & 0x000007
+ *
+ * Operation count: 5 <<, 6 &, 5 | (n.b. rgb >> 3 is used twice)
+ */
+inline static int rgb565To888(int rgb)
+
+{
+ int rgb3 = rgb >> 3;
+ return (((rgb << 8) & 0xf80000) |
+ ( rgb3 & 0x070000) |
+ ((rgb << 5) & 0x00fc00) |
+ ((rgb >> 1) & 0x000300) |
+ ( rgb3 & 0x0000f8) |
+ ((rgb >> 2) & 0x000007));
+}
+
+#if __BYTE_ORDER == __BIG_ENDIAN
+static uint32_t swap(uint32_t x) {
+ int b0 = (x >> 24) & 0xff;
+ int b1 = (x >> 16) & 0xff;
+ int b2 = (x >> 8) & 0xff;
+ int b3 = (x ) & 0xff;
+
+ return (uint32_t)((b3 << 24) | (b2 << 16) | (b1 << 8) | b0);
+}
+#endif
+
+static void
+init_tables()
+{
+ if (tables_initialized) {
+ return;
+ }
+
+ for (int i = 0; i < 64; i++) {
+ for (int j = 0; j < 64; j++) {
+ int avg = (2*i + j)/3;
+ avg23tab[(i << 6) | j] = avg;
+ }
+ }
+
+ asm volatile ("" : : : "memory");
+ tables_initialized = 1;
+}
+
+/*
+ * Utility to scan a DXT1 compressed texture to determine whether it
+ * contains a transparent pixel (color0 < color1, code == 3). This
+ * may be useful if the application lacks information as to whether
+ * the true format is GL_COMPRESSED_RGB_S3TC_DXT1_EXT or
+ * GL_COMPRESSED_RGBA_S3TC_DXT1_EXT.
+ */
+bool
+DXT1HasAlpha(const GLvoid *data, int width, int height) {
+#if TIMING
+ struct timeval start_t, end_t;
+ struct timezone tz;
+
+ gettimeofday(&start_t, &tz);
+#endif
+
+ bool hasAlpha = false;
+
+ int xblocks = (width + 3)/4;
+ int yblocks = (height + 3)/4;
+ int numblocks = xblocks*yblocks;
+
+ uint32_t const *d32 = (uint32_t *)data;
+ for (int b = 0; b < numblocks; b++) {
+ uint32_t colors = *d32++;
+
+#if __BYTE_ORDER == __BIG_ENDIAN
+ colors = swap(colors);
+#endif
+
+ uint16_t color0 = colors & 0xffff;
+ uint16_t color1 = colors >> 16;
+
+ if (color0 < color1) {
+ // There's no need to endian-swap within 'bits'
+ // since we don't care which pixel is the transparent one
+ uint32_t bits = *d32++;
+
+ // Detect if any (odd, even) pair of bits are '11'
+ // bits: b31 b30 b29 ... b3 b2 b1 b0
+ // bits >> 1: b31 b31 b30 ... b4 b3 b2 b1
+ // &: b31 (b31 & b30) (b29 & b28) ... (b2 & b1) (b1 & b0)
+ // & 0x55..: 0 (b31 & b30) 0 ... 0 (b1 & b0)
+ if (((bits & (bits >> 1)) & 0x55555555) != 0) {
+ hasAlpha = true;
+ goto done;
+ }
+ } else {
+ // Skip 4 bytes
+ ++d32;
+ }
+ }
+
+ done:
+#if TIMING
+ gettimeofday(&end_t, &tz);
+ long usec = (end_t.tv_sec - start_t.tv_sec)*1000000 +
+ (end_t.tv_usec - start_t.tv_usec);
+
+ printf("Scanned w=%d h=%d in %ld usec\n", width, height, usec);
+#endif
+
+ return hasAlpha;
+}
+
+static void
+decodeDXT1(const GLvoid *data, int width, int height,
+ void *surface, int stride,
+ bool hasAlpha)
+
+{
+ init_tables();
+
+ uint32_t const *d32 = (uint32_t *)data;
+
+ // Color table for the current block
+ uint16_t c[4];
+ c[0] = c[1] = c[2] = c[3] = 0;
+
+ // Specified colors from the previous block
+ uint16_t prev_color0 = 0x0000;
+ uint16_t prev_color1 = 0x0000;
+
+ uint16_t* rowPtr = (uint16_t*)surface;
+ for (int base_y = 0; base_y < height; base_y += 4, rowPtr += 4*stride) {
+ uint16_t *blockPtr = rowPtr;
+ for (int base_x = 0; base_x < width; base_x += 4, blockPtr += 4) {
+ uint32_t colors = *d32++;
+ uint32_t bits = *d32++;
+
+#if __BYTE_ORDER == __BIG_ENDIAN
+ colors = swap(colors);
+ bits = swap(bits);
+#endif
+
+ // Raw colors
+ uint16_t color0 = colors & 0xffff;
+ uint16_t color1 = colors >> 16;
+
+ // If the new block has the same base colors as the
+ // previous one, we don't need to recompute the color
+ // table c[]
+ if (color0 != prev_color0 || color1 != prev_color1) {
+ // Store raw colors for comparison with next block
+ prev_color0 = color0;
+ prev_color1 = color1;
+
+ int r0 = red(color0);
+ int g0 = green(color0);
+ int b0 = blue(color0);
+
+ int r1 = red(color1);
+ int g1 = green(color1);
+ int b1 = blue(color1);
+
+ if (hasAlpha) {
+ c[0] = (r0 << 11) | ((g0 >> 1) << 6) | (b0 << 1) | 0x1;
+ c[1] = (r1 << 11) | ((g1 >> 1) << 6) | (b1 << 1) | 0x1;
+ } else {
+ c[0] = color0;
+ c[1] = color1;
+ }
+
+ int r2, g2, b2, r3, g3, b3, a3;
+
+ int bbits = bits >> 1;
+ bool has2 = ((bbits & ~bits) & 0x55555555) != 0;
+ bool has3 = ((bbits & bits) & 0x55555555) != 0;
+
+ if (has2 || has3) {
+ if (color0 > color1) {
+ r2 = avg23(r0, r1);
+ g2 = avg23(g0, g1);
+ b2 = avg23(b0, b1);
+
+ r3 = avg23(r1, r0);
+ g3 = avg23(g1, g0);
+ b3 = avg23(b1, b0);
+ a3 = 1;
+ } else {
+ r2 = (r0 + r1) >> 1;
+ g2 = (g0 + g1) >> 1;
+ b2 = (b0 + b1) >> 1;
+
+ r3 = g3 = b3 = a3 = 0;
+ }
+ if (hasAlpha) {
+ c[2] = (r2 << 11) | ((g2 >> 1) << 6) |
+ (b2 << 1) | 0x1;
+ c[3] = (r3 << 11) | ((g3 >> 1) << 6) |
+ (b3 << 1) | a3;
+ } else {
+ c[2] = (r2 << 11) | (g2 << 5) | b2;
+ c[3] = (r3 << 11) | (g3 << 5) | b3;
+ }
+ }
+ }
+
+ uint16_t* blockRowPtr = blockPtr;
+ for (int y = 0; y < 4; y++, blockRowPtr += stride) {
+ // Don't process rows past the botom
+ if (base_y + y >= height) {
+ break;
+ }
+
+ int w = min(width - base_x, 4);
+ for (int x = 0; x < w; x++) {
+ int code = bits & 0x3;
+ bits >>= 2;
+
+ blockRowPtr[x] = c[code];
+ }
+ }
+ }
+ }
+}
+
+// Output data as internalformat=GL_RGBA, type=GL_UNSIGNED_BYTE
+static void
+decodeDXT3(const GLvoid *data, int width, int height,
+ void *surface, int stride)
+
+{
+ init_tables();
+
+ uint32_t const *d32 = (uint32_t *)data;
+
+ // Specified colors from the previous block
+ uint16_t prev_color0 = 0x0000;
+ uint16_t prev_color1 = 0x0000;
+
+ // Color table for the current block
+ uint32_t c[4];
+ c[0] = c[1] = c[2] = c[3] = 0;
+
+ uint32_t* rowPtr = (uint32_t*)surface;
+ for (int base_y = 0; base_y < height; base_y += 4, rowPtr += 4*stride) {
+ uint32_t *blockPtr = rowPtr;
+ for (int base_x = 0; base_x < width; base_x += 4, blockPtr += 4) {
+
+#if __BYTE_ORDER == __BIG_ENDIAN
+ uint32_t alphahi = *d32++;
+ uint32_t alphalo = *d32++;
+ alphahi = swap(alphahi);
+ alphalo = swap(alphalo);
+#else
+ uint32_t alphalo = *d32++;
+ uint32_t alphahi = *d32++;
+#endif
+
+ uint32_t colors = *d32++;
+ uint32_t bits = *d32++;
+
+#if __BYTE_ORDER == __BIG_ENDIAN
+ colors = swap(colors);
+ bits = swap(bits);
+#endif
+
+ uint64_t alpha = ((uint64_t)alphahi << 32) | alphalo;
+
+ // Raw colors
+ uint16_t color0 = colors & 0xffff;
+ uint16_t color1 = colors >> 16;
+
+ // If the new block has the same base colors as the
+ // previous one, we don't need to recompute the color
+ // table c[]
+ if (color0 != prev_color0 || color1 != prev_color1) {
+ // Store raw colors for comparison with next block
+ prev_color0 = color0;
+ prev_color1 = color1;
+
+ int bbits = bits >> 1;
+ bool has2 = ((bbits & ~bits) & 0x55555555) != 0;
+ bool has3 = ((bbits & bits) & 0x55555555) != 0;
+
+ if (has2 || has3) {
+ int r0 = red(color0);
+ int g0 = green(color0);
+ int b0 = blue(color0);
+
+ int r1 = red(color1);
+ int g1 = green(color1);
+ int b1 = blue(color1);
+
+ int r2 = avg23(r0, r1);
+ int g2 = avg23(g0, g1);
+ int b2 = avg23(b0, b1);
+
+ int r3 = avg23(r1, r0);
+ int g3 = avg23(g1, g0);
+ int b3 = avg23(b1, b0);
+
+ c[0] = rgb565SepTo888(r0, g0, b0);
+ c[1] = rgb565SepTo888(r1, g1, b1);
+ c[2] = rgb565SepTo888(r2, g2, b2);
+ c[3] = rgb565SepTo888(r3, g3, b3);
+ } else {
+ // Convert to 8 bits
+ c[0] = rgb565To888(color0);
+ c[1] = rgb565To888(color1);
+ }
+ }
+
+ uint32_t* blockRowPtr = blockPtr;
+ for (int y = 0; y < 4; y++, blockRowPtr += stride) {
+ // Don't process rows past the botom
+ if (base_y + y >= height) {
+ break;
+ }
+
+ int w = min(width - base_x, 4);
+ for (int x = 0; x < w; x++) {
+ int a = alpha & 0xf;
+ alpha >>= 4;
+
+ int code = bits & 0x3;
+ bits >>= 2;
+
+ blockRowPtr[x] = c[code] | (a << 28) | (a << 24);
+ }
+ }
+ }
+ }
+}
+
+// Output data as internalformat=GL_RGBA, type=GL_UNSIGNED_BYTE
+static void
+decodeDXT5(const GLvoid *data, int width, int height,
+ void *surface, int stride)
+
+{
+ init_tables();
+
+ uint32_t const *d32 = (uint32_t *)data;
+
+ // Specified alphas from the previous block
+ uint8_t prev_alpha0 = 0x00;
+ uint8_t prev_alpha1 = 0x00;
+
+ // Specified colors from the previous block
+ uint16_t prev_color0 = 0x0000;
+ uint16_t prev_color1 = 0x0000;
+
+ // Alpha table for the current block
+ uint8_t a[8];
+ a[0] = a[1] = a[2] = a[3] = a[4] = a[5] = a[6] = a[7] = 0;
+
+ // Color table for the current block
+ uint32_t c[4];
+ c[0] = c[1] = c[2] = c[3] = 0;
+
+ int good_a5 = 0;
+ int bad_a5 = 0;
+ int good_a6 = 0;
+ int bad_a6 = 0;
+ int good_a7 = 0;
+ int bad_a7 = 0;
+
+ uint32_t* rowPtr = (uint32_t*)surface;
+ for (int base_y = 0; base_y < height; base_y += 4, rowPtr += 4*stride) {
+ uint32_t *blockPtr = rowPtr;
+ for (int base_x = 0; base_x < width; base_x += 4, blockPtr += 4) {
+
+#if __BYTE_ORDER == __BIG_ENDIAN
+ uint32_t alphahi = *d32++;
+ uint32_t alphalo = *d32++;
+ alphahi = swap(alphahi);
+ alphalo = swap(alphalo);
+#else
+ uint32_t alphalo = *d32++;
+ uint32_t alphahi = *d32++;
+#endif
+
+ uint32_t colors = *d32++;
+ uint32_t bits = *d32++;
+
+#if __BYTE_ORDER == __BIG_ENDIANx
+ colors = swap(colors);
+ bits = swap(bits);
+#endif
+
+ uint64_t alpha = ((uint64_t)alphahi << 32) | alphalo;
+ uint64_t alpha0 = alpha & 0xff;
+ alpha >>= 8;
+ uint64_t alpha1 = alpha & 0xff;
+ alpha >>= 8;
+
+ if (alpha0 != prev_alpha0 || alpha1 != prev_alpha1) {
+ prev_alpha0 = alpha0;
+ prev_alpha1 = alpha1;
+
+ a[0] = alpha0;
+ a[1] = alpha1;
+ int a01 = alpha0 + alpha1 - 1;
+ if (alpha0 > alpha1) {
+ a[2] = div7(6*alpha0 + alpha1);
+ a[4] = div7(4*alpha0 + 3*alpha1);
+ a[6] = div7(2*alpha0 + 5*alpha1);
+
+ // Use symmetry to derive half of the values
+ // A few values will be off by 1 (~.5%)
+ // Alternate which values are computed directly
+ // and which are derived to try to reduce bias
+ a[3] = a01 - a[6];
+ a[5] = a01 - a[4];
+ a[7] = a01 - a[2];
+ } else {
+ a[2] = div5(4*alpha0 + alpha1);
+ a[4] = div5(2*alpha0 + 3*alpha1);
+ a[3] = a01 - a[4];
+ a[5] = a01 - a[2];
+ a[6] = 0x00;
+ a[7] = 0xff;
+ }
+ }
+
+ // Raw colors
+ uint16_t color0 = colors & 0xffff;
+ uint16_t color1 = colors >> 16;
+
+ // If the new block has the same base colors as the
+ // previous one, we don't need to recompute the color
+ // table c[]
+ if (color0 != prev_color0 || color1 != prev_color1) {
+ // Store raw colors for comparison with next block
+ prev_color0 = color0;
+ prev_color1 = color1;
+
+ int bbits = bits >> 1;
+ bool has2 = ((bbits & ~bits) & 0x55555555) != 0;
+ bool has3 = ((bbits & bits) & 0x55555555) != 0;
+
+ if (has2 || has3) {
+ int r0 = red(color0);
+ int g0 = green(color0);
+ int b0 = blue(color0);
+
+ int r1 = red(color1);
+ int g1 = green(color1);
+ int b1 = blue(color1);
+
+ int r2 = avg23(r0, r1);
+ int g2 = avg23(g0, g1);
+ int b2 = avg23(b0, b1);
+
+ int r3 = avg23(r1, r0);
+ int g3 = avg23(g1, g0);
+ int b3 = avg23(b1, b0);
+
+ c[0] = rgb565SepTo888(r0, g0, b0);
+ c[1] = rgb565SepTo888(r1, g1, b1);
+ c[2] = rgb565SepTo888(r2, g2, b2);
+ c[3] = rgb565SepTo888(r3, g3, b3);
+ } else {
+ // Convert to 8 bits
+ c[0] = rgb565To888(color0);
+ c[1] = rgb565To888(color1);
+ }
+ }
+
+ uint32_t* blockRowPtr = blockPtr;
+ for (int y = 0; y < 4; y++, blockRowPtr += stride) {
+ // Don't process rows past the botom
+ if (base_y + y >= height) {
+ break;
+ }
+
+ int w = min(width - base_x, 4);
+ for (int x = 0; x < w; x++) {
+ int acode = alpha & 0x7;
+ alpha >>= 3;
+
+ int code = bits & 0x3;
+ bits >>= 2;
+
+ blockRowPtr[x] = c[code] | (a[acode] << 24);
+ }
+ }
+ }
+ }
+}
+
+/*
+ * Decode a DXT-compressed texture into memory. DXT textures consist of
+ * a series of 4x4 pixel blocks in left-to-right, top-down order.
+ * The number of blocks is given by ceil(width/4)*ceil(height/4).
+ *
+ * 'data' points to the texture data. 'width' and 'height' indicate the
+ * dimensions of the texture. We assume width and height are >= 0 but
+ * do not require them to be powers of 2 or divisible by any factor.
+ *
+ * The output is written to 'surface' with each scanline separated by
+ * 'stride' 2- or 4-byte words.
+ *
+ * 'format' indicates the type of compression and must be one of the following:
+ *
+ * GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
+ * The output is written as 5/6/5 opaque RGB (16 bit words).
+ * 8 bytes are read from 'data' for each block.
+ *
+ * GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
+ * The output is written as 5/5/5/1 RGBA (16 bit words)
+ * 8 bytes are read from 'data' for each block.
+ *
+ * GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
+ * GL_COMPRESSED_RGBA_S3TC_DXT5_EXT
+ * The output is written as 8/8/8/8 ARGB (32 bit words)
+ * 16 bytes are read from 'data' for each block.
+ */
+void
+decodeDXT(const GLvoid *data, int width, int height,
+ void *surface, int stride, int format)
+{
+#if TIMING
+ struct timeval start_t, end_t;
+ struct timezone tz;
+
+ gettimeofday(&start_t, &tz);
+#endif
+
+ switch (format) {
+ case GL_COMPRESSED_RGB_S3TC_DXT1_EXT:
+ decodeDXT1(data, width, height, surface, stride, false);
+ break;
+
+ case GL_COMPRESSED_RGBA_S3TC_DXT1_EXT:
+ decodeDXT1(data, width, height, surface, stride, true);
+ break;
+
+ case GL_COMPRESSED_RGBA_S3TC_DXT3_EXT:
+ decodeDXT3(data, width, height, surface, stride);
+ break;
+
+ case GL_COMPRESSED_RGBA_S3TC_DXT5_EXT:
+ decodeDXT5(data, width, height, surface, stride);
+ break;
+ }
+
+#if TIMING
+ gettimeofday(&end_t, &tz);
+ long usec = (end_t.tv_sec - start_t.tv_sec)*1000000 +
+ (end_t.tv_usec - start_t.tv_usec);
+
+ printf("Loaded w=%d h=%d in %ld usec\n", width, height, usec);
+#endif
+}
+
+} // namespace android
diff --git a/opengl/libagl/dxt.h b/opengl/libagl/dxt.h
new file mode 100644
index 0000000..d95a36c
--- /dev/null
+++ b/opengl/libagl/dxt.h
@@ -0,0 +1,33 @@
+/* libs/opengles/dxt.h
+**
+** 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.
+*/
+
+#ifndef ANDROID_OPENGLES_TEXTURE_H
+#define ANDROID_OPENGLES_TEXTURE_H
+
+#include <stdlib.h>
+
+#include <GLES/gl.h>
+
+namespace android {
+
+ bool DXT1HasAlpha(const GLvoid *data, int width, int height);
+ void decodeDXT(const GLvoid *data, int width, int height,
+ void *surface, int stride, int format);
+
+} // namespace android
+
+#endif // ANDROID_OPENGLES_TEXTURE_H
diff --git a/opengl/libagl/egl.cpp b/opengl/libagl/egl.cpp
new file mode 100644
index 0000000..5b90bf0
--- /dev/null
+++ b/opengl/libagl/egl.cpp
@@ -0,0 +1,1543 @@
+/*
+**
+** 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.
+*/
+
+#define LOG_TAG "EGL"
+
+#include <assert.h>
+#include <errno.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/ioctl.h>
+#include <sys/types.h>
+#include <sys/mman.h>
+
+#include <cutils/log.h>
+#include <cutils/atomic.h>
+
+#include <utils/threads.h>
+
+#include <EGL/egl.h>
+#include <EGL/eglext.h>
+#include <GLES/gl.h>
+#include <GLES/glext.h>
+
+#include <pixelflinger/format.h>
+#include <pixelflinger/pixelflinger.h>
+
+#include "context.h"
+#include "state.h"
+#include "texture.h"
+#include "matrix.h"
+
+#undef NELEM
+#define NELEM(x) (sizeof(x)/sizeof(*(x)))
+
+// ----------------------------------------------------------------------------
+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<typename T>
+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);
+ 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_context_t {
+ enum {
+ IS_CURRENT = 0x00010000,
+ NEVER_CURRENT = 0x00020000
+ };
+ uint32_t flags;
+ EGLDisplay dpy;
+ EGLConfig config;
+ EGLSurface read;
+ EGLSurface draw;
+
+ static inline egl_context_t* context(EGLContext ctx) {
+ ogles_context_t* const gl = static_cast<ogles_context_t*>(ctx);
+ return static_cast<egl_context_t*>(gl->rasterizer.base);
+ }
+};
+
+// ----------------------------------------------------------------------------
+
+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();
+ virtual bool isValid() const = 0;
+
+ virtual EGLBoolean bindDrawSurface(ogles_context_t* gl) = 0;
+ virtual EGLBoolean bindReadSurface(ogles_context_t* gl) = 0;
+ virtual EGLint getWidth() const = 0;
+ virtual EGLint getHeight() const = 0;
+ virtual void* getBits() const = 0;
+
+ virtual EGLint getHorizontalResolution() const;
+ virtual EGLint getVerticalResolution() const;
+ virtual EGLint getRefreshRate() const;
+ virtual EGLint getSwapBehavior() const;
+ virtual EGLBoolean swapBuffers();
+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 = depthFormat;
+}
+egl_surface_t::~egl_surface_t()
+{
+ magic = 0;
+ free(depth.data);
+}
+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;
+}
+
+// ----------------------------------------------------------------------------
+
+struct egl_window_surface_t : public egl_surface_t
+{
+ egl_window_surface_t(
+ EGLDisplay dpy, EGLConfig config,
+ int32_t depthFormat,
+ egl_native_window_t* window);
+
+ ~egl_window_surface_t();
+
+ virtual bool isValid() const { return nativeWindow->magic == 0x600913; }
+ virtual EGLBoolean swapBuffers();
+ virtual EGLBoolean bindDrawSurface(ogles_context_t* gl);
+ virtual EGLBoolean bindReadSurface(ogles_context_t* gl);
+ virtual EGLint getWidth() const { return nativeWindow->width; }
+ virtual EGLint getHeight() const { return nativeWindow->height; }
+ virtual void* getBits() const;
+ virtual EGLint getHorizontalResolution() const;
+ virtual EGLint getVerticalResolution() const;
+ virtual EGLint getRefreshRate() const;
+ virtual EGLint getSwapBehavior() const;
+private:
+ egl_native_window_t* nativeWindow;
+};
+
+egl_window_surface_t::egl_window_surface_t(EGLDisplay dpy,
+ EGLConfig config,
+ int32_t depthFormat,
+ egl_native_window_t* window)
+ : egl_surface_t(dpy, config, depthFormat), nativeWindow(window)
+{
+ if (depthFormat) {
+ depth.width = window->width;
+ depth.height = window->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;
+ }
+ }
+ nativeWindow->incRef(nativeWindow);
+}
+egl_window_surface_t::~egl_window_surface_t() {
+ nativeWindow->decRef(nativeWindow);
+}
+
+EGLBoolean egl_window_surface_t::swapBuffers()
+{
+ uint32_t flags = nativeWindow->swapBuffers(nativeWindow);
+ if (flags & EGL_NATIVES_FLAG_SIZE_CHANGED) {
+ // TODO: we probably should reset the swap rect here
+ // if the window size has changed
+ if (depth.data) {
+ free(depth.data);
+ depth.width = nativeWindow->width;
+ depth.height = nativeWindow->height;
+ depth.stride = nativeWindow->stride;
+ depth.data = (GGLubyte*)malloc(depth.stride*depth.height*2);
+ if (depth.data == 0) {
+ setError(EGL_BAD_ALLOC, EGL_NO_SURFACE);
+ return EGL_FALSE;
+ }
+ }
+ }
+ return EGL_TRUE;
+}
+
+EGLBoolean egl_window_surface_t::bindDrawSurface(ogles_context_t* gl)
+{
+ GGLSurface buffer;
+ buffer.version = sizeof(GGLSurface);
+ buffer.width = nativeWindow->width;
+ buffer.height = nativeWindow->height;
+ buffer.stride = nativeWindow->stride;
+ buffer.data = (GGLubyte*)nativeWindow->base + nativeWindow->offset;
+ buffer.format = nativeWindow->format;
+ gl->rasterizer.procs.colorBuffer(gl, &buffer);
+ if (depth.data != gl->rasterizer.state.buffers.depth.data)
+ gl->rasterizer.procs.depthBuffer(gl, &depth);
+ return EGL_TRUE;
+}
+EGLBoolean egl_window_surface_t::bindReadSurface(ogles_context_t* gl)
+{
+ GGLSurface buffer;
+ buffer.version = sizeof(GGLSurface);
+ buffer.width = nativeWindow->width;
+ buffer.height = nativeWindow->height;
+ buffer.stride = nativeWindow->stride;
+ buffer.data = (GGLubyte*)nativeWindow->base + nativeWindow->offset;
+ buffer.format = nativeWindow->format;
+ gl->rasterizer.procs.readBuffer(gl, &buffer);
+ return EGL_TRUE;
+}
+void* egl_window_surface_t::getBits() const {
+ return (GGLubyte*)nativeWindow->base + nativeWindow->offset;
+}
+EGLint egl_window_surface_t::getHorizontalResolution() const {
+ return (nativeWindow->xdpi * EGL_DISPLAY_SCALING) * (1.0f / 25.4f);
+}
+EGLint egl_window_surface_t::getVerticalResolution() const {
+ return (nativeWindow->ydpi * EGL_DISPLAY_SCALING) * (1.0f / 25.4f);
+}
+EGLint egl_window_surface_t::getRefreshRate() const {
+ return (nativeWindow->fps * EGL_DISPLAY_SCALING);
+}
+EGLint egl_window_surface_t::getSwapBehavior() const {
+ uint32_t flags = nativeWindow->flags;
+ if (flags & EGL_NATIVES_FLAG_DESTROY_BACKBUFFER)
+ return EGL_BUFFER_DESTROYED;
+ return EGL_BUFFER_PRESERVED;
+}
+
+// ----------------------------------------------------------------------------
+
+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 isValid() const { return nativePixmap.version == sizeof(egl_native_pixmap_t); }
+ virtual EGLBoolean bindDrawSurface(ogles_context_t* gl);
+ virtual EGLBoolean bindReadSurface(ogles_context_t* gl);
+ virtual EGLint getWidth() const { return nativePixmap.width; }
+ virtual EGLint getHeight() const { return nativePixmap.height; }
+ virtual void* getBits() const { return nativePixmap.data; }
+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);
+ return;
+ }
+ }
+}
+EGLBoolean egl_pixmap_surface_t::bindDrawSurface(ogles_context_t* 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 = nativePixmap.format;
+
+ gl->rasterizer.procs.colorBuffer(gl, &buffer);
+ if (depth.data != gl->rasterizer.state.buffers.depth.data)
+ gl->rasterizer.procs.depthBuffer(gl, &depth);
+ return EGL_TRUE;
+}
+EGLBoolean egl_pixmap_surface_t::bindReadSurface(ogles_context_t* 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 = nativePixmap.format;
+ gl->rasterizer.procs.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 isValid() const { return pbuffer.data != 0; }
+ virtual EGLBoolean bindDrawSurface(ogles_context_t* gl);
+ virtual EGLBoolean bindReadSurface(ogles_context_t* gl);
+ virtual EGLint getWidth() const { return pbuffer.width; }
+ virtual EGLint getHeight() const { return pbuffer.height; }
+ virtual void* getBits() const { return pbuffer.data; }
+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;
+ 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 = 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(ogles_context_t* gl)
+{
+ gl->rasterizer.procs.colorBuffer(gl, &pbuffer);
+ if (depth.data != gl->rasterizer.state.buffers.depth.data)
+ gl->rasterizer.procs.depthBuffer(gl, &depth);
+ return EGL_TRUE;
+}
+EGLBoolean egl_pbuffer_surface_t::bindReadSurface(ogles_context_t* gl)
+{
+ gl->rasterizer.procs.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;
+ }
+};
+
+// ----------------------------------------------------------------------------
+
+#define VERSION_MAJOR 1
+#define VERSION_MINOR 2
+static char const * const gVendorString = "Google Inc.";
+static char const * const gVersionString = "1.2 Android Driver";
+static char const * const gClientApiString = "OpenGL ES";
+static char const * const gExtensionsString = "";
+
+// ----------------------------------------------------------------------------
+
+struct extention_map_t {
+ const char * const name;
+ __eglMustCastToProperFunctionPointerType address;
+};
+
+static const extention_map_t gExtentionMap[] = {
+ { "glDrawTexsOES", (void(*)())&glDrawTexsOES },
+ { "glDrawTexiOES", (void(*)())&glDrawTexiOES },
+ { "glDrawTexfOES", (void(*)())&glDrawTexfOES },
+ { "glDrawTexxOES", (void(*)())&glDrawTexxOES },
+ { "glDrawTexsvOES", (void(*)())&glDrawTexsvOES },
+ { "glDrawTexivOES", (void(*)())&glDrawTexivOES },
+ { "glDrawTexfvOES", (void(*)())&glDrawTexfvOES },
+ { "glDrawTexxvOES", (void(*)())&glDrawTexxvOES },
+ { "glQueryMatrixxOES", (void(*)())&glQueryMatrixxOES },
+ { "glClipPlanef", (void(*)())&glClipPlanef },
+ { "glClipPlanex", (void(*)())&glClipPlanex },
+ { "glBindBuffer", (void(*)())&glBindBuffer },
+ { "glBufferData", (void(*)())&glBufferData },
+ { "glBufferSubData", (void(*)())&glBufferSubData },
+ { "glDeleteBuffers", (void(*)())&glDeleteBuffers },
+ { "glGenBuffers", (void(*)())&glGenBuffers },
+};
+
+/*
+ * 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_RGB_565 },
+ { 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, 4 },
+};
+
+// These configs can override the base attribute list
+// NOTE: when adding a config here, don't forget to update eglCreate*Surface()
+
+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_SURFACE_TYPE, 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_SURFACE_TYPE, EGL_WINDOW_BIT|EGL_PBUFFER_BIT|EGL_PIXMAP_BIT },
+};
+
+static config_pair_t const config_2_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_SURFACE_TYPE, 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, 8 },
+ { EGL_BLUE_SIZE, 8 },
+ { EGL_GREEN_SIZE, 8 },
+ { EGL_RED_SIZE, 8 },
+ { EGL_DEPTH_SIZE, 16 },
+ { EGL_CONFIG_ID, 3 },
+ { EGL_SURFACE_TYPE, EGL_WINDOW_BIT|EGL_PBUFFER_BIT|EGL_PIXMAP_BIT },
+};
+
+static config_pair_t const config_4_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_SURFACE_TYPE, EGL_WINDOW_BIT|EGL_PBUFFER_BIT|EGL_PIXMAP_BIT },
+};
+
+static config_pair_t const config_5_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_SURFACE_TYPE, 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) },
+};
+
+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::exact },
+ { EGL_MAX_PBUFFER_PIXELS, config_management_t::exact },
+ { EGL_MAX_PBUFFER_WIDTH, config_management_t::exact },
+ { EGL_NATIVE_RENDERABLE, config_management_t::exact },
+ { EGL_NATIVE_VISUAL_ID, config_management_t::exact },
+ { 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 },
+};
+
+static config_pair_t const config_defaults[] = {
+ { EGL_SURFACE_TYPE, EGL_WINDOW_BIT },
+};
+
+// ----------------------------------------------------------------------------
+
+template<typename T>
+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<config_pair_t>(
+ gConfigs[i].array,
+ 0, gConfigs[i].size-1,
+ attr);
+ if (index < 0) {
+ configFound = config_base_attribute_list;
+ index = binarySearch<config_pair_t>(
+ 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<config_management_t>(
+ gConfigManagement,
+ 0, NELEM(gConfigManagement)-1,
+ attr);
+ if (index >= 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(ogles_context_t* gl)
+{
+ ogles_context_t* current = (ogles_context_t*)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<config_pair_t>(
+ gConfigs[index].array,
+ 0, gConfigs[index].size-1,
+ attribute);
+ if (attrIndex>=0) {
+ *value = gConfigs[index].array[attrIndex].value;
+ return EGL_TRUE;
+ }
+
+ attrIndex = binarySearch<config_pair_t>(
+ 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);
+
+ EGLint configID;
+ if (getConfigAttrib(dpy, config, EGL_CONFIG_ID, &configID) == EGL_FALSE)
+ return EGL_FALSE;
+
+ int32_t depthFormat;
+ int32_t pixelFormat;
+ 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_16;
+ 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_16;
+ break;
+ case 4:
+ pixelFormat = GGL_PIXEL_FORMAT_A_8;
+ depthFormat = 0;
+ break;
+ case 5:
+ pixelFormat = GGL_PIXEL_FORMAT_A_8;
+ depthFormat = GGL_PIXEL_FORMAT_Z_16;
+ break;
+ default:
+ 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 =
+ new egl_window_surface_t(dpy, config, depthFormat,
+ static_cast<egl_native_window_t*>(window));
+
+ if (!surface->isValid()) {
+ // 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);
+
+ EGLint configID;
+ if (getConfigAttrib(dpy, config, EGL_CONFIG_ID, &configID) == EGL_FALSE)
+ return EGL_FALSE;
+
+ int32_t depthFormat;
+ int32_t pixelFormat;
+ 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_16;
+ 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_16;
+ break;
+ case 4:
+ pixelFormat = GGL_PIXEL_FORMAT_A_8;
+ depthFormat = 0;
+ break;
+ case 5:
+ pixelFormat = GGL_PIXEL_FORMAT_A_8;
+ depthFormat = GGL_PIXEL_FORMAT_Z_16;
+ break;
+ default:
+ return setError(EGL_BAD_MATCH, EGL_NO_SURFACE);
+ }
+
+ if (pixmap->format != pixelFormat)
+ return setError(EGL_BAD_MATCH, EGL_NO_SURFACE);
+
+ egl_surface_t* surface =
+ new egl_pixmap_surface_t(dpy, config, depthFormat,
+ static_cast<egl_native_pixmap_t*>(pixmap));
+
+ if (!surface->isValid()) {
+ // 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;
+ 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_16;
+ 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_16;
+ break;
+ case 4:
+ pixelFormat = GGL_PIXEL_FORMAT_A_8;
+ depthFormat = 0;
+ break;
+ case 5:
+ pixelFormat = GGL_PIXEL_FORMAT_A_8;
+ depthFormat = GGL_PIXEL_FORMAT_Z_16;
+ break;
+ default:
+ 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->isValid()) {
+ // 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)
+{
+#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)
+{
+ 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)
+{
+ 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)
+{
+ 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<numConfigs && i<config_size ; i++) {
+ *configs++ = (EGLConfig)i;
+ }
+ *num_config = i;
+ return EGL_TRUE;
+}
+
+EGLBoolean eglChooseConfig( EGLDisplay dpy, const EGLint *attrib_list,
+ EGLConfig *configs, EGLint config_size,
+ EGLint *num_config)
+{
+ if (egl_display_t::is_valid(dpy) == EGL_FALSE)
+ return setError(EGL_BAD_DISPLAY, EGL_FALSE);
+
+ if (ggl_unlikely(configs==0 || attrib_list==0)) {
+ *num_config = 0;
+ return EGL_TRUE;
+ }
+
+ int numAttributes = 0;
+ int numConfigs = NELEM(gConfigs);
+ uint32_t possibleMatch = (1<<numConfigs)-1;
+ while(possibleMatch && *attrib_list != EGL_NONE) {
+ numAttributes++;
+ EGLint attr = *attrib_list++;
+ EGLint val = *attrib_list++;
+ for (int i=0 ; i<numConfigs ; i++) {
+ if (!(possibleMatch & (1<<i)))
+ continue;
+ if (isAttributeMatching(i, attr, val) == 0) {
+ possibleMatch &= ~(1<<i);
+ }
+ }
+ }
+
+ // now, handle the attributes which have a useful default value
+ for (size_t j=0 ; j<NELEM(config_defaults) ; j++) {
+ // see if this attribute was specified, if not apply its
+ // default value
+ if (binarySearch<config_pair_t>(
+ (config_pair_t const*)attrib_list,
+ 0, numAttributes,
+ config_defaults[j].key) < 0)
+ {
+ for (int i=0 ; i<numConfigs ; i++) {
+ if (!(possibleMatch & (1<<i)))
+ continue;
+ if (isAttributeMatching(i,
+ config_defaults[j].key,
+ config_defaults[j].value) == 0)
+ {
+ possibleMatch &= ~(1<<i);
+ }
+ }
+ }
+ }
+
+ // return the configurations found
+ int n=0;
+ if (possibleMatch) {
+ for (int i=0 ; config_size && i<numConfigs ; i++) {
+ if (possibleMatch & (1<<i)) {
+ *configs++ = (EGLConfig)i;
+ config_size--;
+ n++;
+ }
+ }
+ }
+ *num_config = n;
+ return EGL_TRUE;
+}
+
+EGLBoolean eglGetConfigAttrib(EGLDisplay dpy, EGLConfig config,
+ EGLint attribute, EGLint *value)
+{
+ if (egl_display_t::is_valid(dpy) == EGL_FALSE)
+ return setError(EGL_BAD_DISPLAY, EGL_FALSE);
+
+ return getConfigAttrib(dpy, config, attribute, value);
+}
+
+// ----------------------------------------------------------------------------
+// surfaces
+// ----------------------------------------------------------------------------
+
+EGLSurface eglCreateWindowSurface( EGLDisplay dpy, EGLConfig config,
+ NativeWindowType window,
+ const EGLint *attrib_list)
+{
+ return createWindowSurface(dpy, config, window, attrib_list);
+}
+
+EGLSurface eglCreatePixmapSurface( EGLDisplay dpy, EGLConfig config,
+ NativePixmapType pixmap,
+ const EGLint *attrib_list)
+{
+ return createPixmapSurface(dpy, config, pixmap, attrib_list);
+}
+
+EGLSurface eglCreatePbufferSurface( EGLDisplay dpy, EGLConfig config,
+ const EGLint *attrib_list)
+{
+ return createPbufferSurface(dpy, config, attrib_list);
+}
+
+EGLBoolean eglDestroySurface(EGLDisplay dpy, EGLSurface eglSurface)
+{
+ if (egl_display_t::is_valid(dpy) == EGL_FALSE)
+ return setError(EGL_BAD_DISPLAY, EGL_FALSE);
+ if (eglSurface != EGL_NO_SURFACE) {
+ egl_surface_t* surface( static_cast<egl_surface_t*>(eglSurface) );
+ if (surface->magic != egl_surface_t::MAGIC)
+ return setError(EGL_BAD_SURFACE, EGL_FALSE);
+ if (surface->dpy != dpy)
+ return setError(EGL_BAD_DISPLAY, EGL_FALSE);
+ delete surface;
+ }
+ return EGL_TRUE;
+}
+
+EGLBoolean eglQuerySurface( EGLDisplay dpy, EGLSurface eglSurface,
+ EGLint attribute, EGLint *value)
+{
+ if (egl_display_t::is_valid(dpy) == EGL_FALSE)
+ return setError(EGL_BAD_DISPLAY, EGL_FALSE);
+ egl_surface_t* surface = static_cast<egl_surface_t*>(eglSurface);
+ 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)
+{
+ if (egl_display_t::is_valid(dpy) == EGL_FALSE)
+ return setError(EGL_BAD_DISPLAY, EGL_NO_SURFACE);
+
+ ogles_context_t* gl = ogles_init(sizeof(egl_context_t));
+ if (!gl) return setError(EGL_BAD_ALLOC, EGL_NO_CONTEXT);
+
+ egl_context_t* c = static_cast<egl_context_t*>(gl->rasterizer.base);
+ c->flags = egl_context_t::NEVER_CURRENT;
+ c->dpy = dpy;
+ c->config = config;
+ c->read = 0;
+ c->draw = 0;
+ return (EGLContext)gl;
+}
+
+EGLBoolean eglDestroyContext(EGLDisplay dpy, EGLContext ctx)
+{
+ 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((ogles_context_t*)ctx);
+ return EGL_TRUE;
+}
+
+EGLBoolean eglMakeCurrent( EGLDisplay dpy, EGLSurface draw,
+ EGLSurface read, EGLContext ctx)
+{
+ 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->dpy != dpy)
+ return setError(EGL_BAD_DISPLAY, EGL_FALSE);
+ // TODO: check that draw and read are 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)) {
+ // once of the surface is bound to a context in another thread
+ return setError(EGL_BAD_ACCESS, EGL_FALSE);
+ }
+ }
+
+ ogles_context_t* gl = (ogles_context_t*)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;
+ c->read = read;
+ c->draw = draw;
+ 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();
+ }
+ ogles_surfaceport(gl, 0, 0);
+ ogles_viewport(gl, 0, 0, w, h);
+ ogles_scissor(gl, 0, 0, w, h);
+ }
+ if (d) {
+ d->ctx = ctx;
+ d->bindDrawSurface(gl);
+ }
+ if (r) {
+ 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) d->ctx = EGL_NO_CONTEXT;
+ if (r) r->ctx = EGL_NO_CONTEXT;
+ }
+ }
+ 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<egl_surface_t*>(draw);
+ 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((ogles_context_t*)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((ogles_context_t*)d->ctx);
+ }
+ }
+
+ 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 setError(EGL_BAD_PARAMETER, EGL_FALSE);
+}
+
+// ----------------------------------------------------------------------------
+// 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);
+}
+
+// ----------------------------------------------------------------------------
+// Android extensions
+// ----------------------------------------------------------------------------
+
+void (*eglGetProcAddress (const char *procname))()
+{
+ extention_map_t const * const map = gExtentionMap;
+ for (uint32_t i=0 ; i<NELEM(gExtentionMap) ; i++) {
+ if (!strcmp(procname, map[i].name)) {
+ return map[i].address;
+ }
+ }
+ return NULL;
+}
diff --git a/opengl/libagl/fixed_asm.S b/opengl/libagl/fixed_asm.S
new file mode 100644
index 0000000..6cbc56f
--- /dev/null
+++ b/opengl/libagl/fixed_asm.S
@@ -0,0 +1,65 @@
+/* libs/opengles/fixed_asm.S
+**
+** Copyright 2006, 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.
+*/
+
+
+ .text
+ .align
+
+ .global gglFloatToFixed
+ .global gglFloatToFixedFast
+
+
+/*
+ * Converts a float to a s15.16 fixed-point number.
+ * this doesn't handle floats out of the [-32768, +32768[ range
+ * and doesn't performs round-to-nearest.
+ * however, it's very fast :-)
+ */
+
+gglFloatToFixedFast:
+ movs r1, r0, lsl #1 /* remove bit sign */
+ mov r2, #0x8E /* 127 + 15 */
+ sub r1, r2, r1, lsr #24 /* compute shift */
+ mov r2, r0, lsl #8 /* mantissa<<8 */
+ orr r2, r2, #0x80000000 /* add the missing 1 */
+ mov r0, r2, lsr r1 /* scale to 16.16 */
+ rsbcs r0, r0, #0 /* negate if needed */
+ bx lr
+
+/*
+ * this version rounds-to-nearest and saturates numbers
+ * outside the range (but not NaNs).
+ */
+
+gglFloatToFixed:
+ mov r1, r0, lsl #1 /* remove bit sign */
+ mov r2, #0x8E /* 127 + 15 */
+ subs r1, r2, r1, lsr #24 /* compute shift */
+ bls 0f /* too big */
+ mov r2, r0, lsl #8 /* mantissa<<8 */
+ orr r2, r2, #0x80000000 /* add the missing 1 */
+ mov r3, r0
+ movs r0, r2, lsr r1 /* scale to 16.16 */
+ addcs r0, r0, #1 /* round-to-nearest */
+ tst r3, #0x80000000 /* negative? */
+ rsbne r0, r0, #0 /* negate if needed */
+ bx lr
+
+0: ands r0, r0, #0x80000000 /* keep only the sign bit */
+ moveq r0, #0x7fffffff /* positive, maximum value */
+ bx lr
+
diff --git a/opengl/libagl/fp.cpp b/opengl/libagl/fp.cpp
new file mode 100644
index 0000000..ae5f1fe
--- /dev/null
+++ b/opengl/libagl/fp.cpp
@@ -0,0 +1,87 @@
+/* libs/opengles/fp.cpp
+**
+** Copyright 2006, 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 "fp.h"
+
+// ----------------------------------------------------------------------------
+
+#if !defined(__arm__)
+GGLfixed gglFloatToFixed(float v) {
+ return GGLfixed(floorf(v * 65536.0f + 0.5f));
+}
+#endif
+
+// ----------------------------------------------------------------------------
+
+namespace android {
+
+namespace gl {
+
+GLfloat fixedToFloat(GLfixed x)
+{
+#if DEBUG_USE_FLOATS
+ return x / 65536.0f;
+#else
+ if (!x) return 0;
+ const uint32_t s = x & 0x80000000;
+ union {
+ uint32_t i;
+ float f;
+ };
+ i = s ? -x : x;
+ const int c = gglClz(i) - 8;
+ i = (c>=0) ? (i<<c) : (i>>-c);
+ const uint32_t e = 134 - c;
+ i &= ~0x800000;
+ i |= e<<23;
+ i |= s;
+ return f;
+#endif
+}
+
+float sinef(float x)
+{
+ const float A = 1.0f / (2.0f*M_PI);
+ const float B = -16.0f;
+ const float C = 8.0f;
+
+ // scale angle for easy argument reduction
+ x *= A;
+
+ if (fabsf(x) >= 0.5f) {
+ // Argument reduction
+ x = x - ceilf(x + 0.5f) + 1.0f;
+ }
+
+ const float y = B*x*fabsf(x) + C*x;
+ return 0.2215f * (y*fabsf(y) - y) + y;
+}
+
+float cosinef(float x)
+{
+ return sinef(x + float(M_PI/2));
+}
+
+void sincosf(GLfloat angle, GLfloat* s, GLfloat* c) {
+ *s = sinef(angle);
+ *c = cosinef(angle);
+}
+
+}; // namespace fp_utils
+
+// ----------------------------------------------------------------------------
+}; // namespace android
diff --git a/opengl/libagl/fp.h b/opengl/libagl/fp.h
new file mode 100644
index 0000000..6d0c183
--- /dev/null
+++ b/opengl/libagl/fp.h
@@ -0,0 +1,243 @@
+/* libs/opengles/fp.h
+**
+** Copyright 2006, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+** http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+#ifndef ANDROID_OPENGLES_FP_H
+#define ANDROID_OPENGLES_FP_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include <sys/types.h>
+#include <math.h>
+
+#include <private/pixelflinger/ggl_context.h>
+
+#include <GLES/gl.h>
+
+#define DEBUG_USE_FLOATS 0
+
+// ----------------------------------------------------------------------------
+
+extern "C" GLfixed gglFloatToFixed(float f) __attribute__((const));
+
+// ----------------------------------------------------------------------------
+namespace android {
+
+namespace gl {
+
+ GLfloat fixedToFloat(GLfixed) CONST;
+
+ void sincosf(GLfloat angle, GLfloat* s, GLfloat* c);
+ float sinef(GLfloat x) CONST;
+ float cosinef(GLfloat x) CONST;
+
+inline bool cmpf(GLfloat a, GLfloat b) CONST;
+inline bool isZerof(GLfloat) CONST;
+inline bool isOnef(GLfloat) CONST;
+
+inline int isZeroOrNegativef(GLfloat) CONST;
+
+inline int exponent(GLfloat) CONST;
+inline int32_t mantissa(GLfloat) CONST;
+inline GLfloat clampToZerof(GLfloat) CONST;
+inline GLfloat reciprocalf(GLfloat) CONST;
+inline GLfloat rsqrtf(GLfloat) CONST;
+inline GLfloat sqrf(GLfloat) CONST;
+inline GLfloat addExpf(GLfloat v, int e) CONST;
+inline GLfloat mul2f(GLfloat v) CONST;
+inline GLfloat div2f(GLfloat v) CONST;
+inline GLfloat absf(GLfloat v) CONST;
+
+
+/*
+ * float fastexpf(float) : a fast approximation of expf(x)
+ * give somewhat accurate results for -88 <= x <= 88
+ *
+ * exp(x) = 2^(x/ln(2))
+ * we use the properties of float encoding
+ * to get a fast 2^ and linear interpolation
+ *
+ */
+
+inline float fastexpf(float y) __attribute__((const));
+
+inline float fastexpf(float y)
+{
+ union {
+ float r;
+ int32_t i;
+ } u;
+
+ // 127*ln(2) = 88
+ if (y < -88.0f) {
+ u.r = 0.0f;
+ } else if (y > 88.0f) {
+ u.r = INFINITY;
+ } else {
+ const float kOneOverLogTwo = (1L<<23) / M_LN2;
+ const int32_t kExponentBias = 127L<<23;
+ const int32_t e = int32_t(y*kOneOverLogTwo);
+ u.i = e + kExponentBias;
+ }
+
+ return u.r;
+}
+
+
+bool cmpf(GLfloat a, GLfloat b) {
+#if DEBUG_USE_FLOATS
+ return a == b;
+#else
+ union {
+ float f;
+ uint32_t i;
+ } ua, ub;
+ ua.f = a;
+ ub.f = b;
+ return ua.i == ub.i;
+#endif
+}
+
+bool isZerof(GLfloat v) {
+#if DEBUG_USE_FLOATS
+ return v == 0;
+#else
+ union {
+ float f;
+ int32_t i;
+ };
+ f = v;
+ return (i<<1) == 0;
+#endif
+}
+
+bool isOnef(GLfloat v) {
+ return cmpf(v, 1.0f);
+}
+
+int isZeroOrNegativef(GLfloat v) {
+#if DEBUG_USE_FLOATS
+ return v <= 0;
+#else
+ union {
+ float f;
+ int32_t i;
+ };
+ f = v;
+ return isZerof(v) | (i>>31);
+#endif
+}
+
+int exponent(GLfloat v) {
+ union {
+ float f;
+ uint32_t i;
+ };
+ f = v;
+ return ((i << 1) >> 24) - 127;
+}
+
+int32_t mantissa(GLfloat v) {
+ union {
+ float f;
+ uint32_t i;
+ };
+ f = v;
+ if (!(i&0x7F800000)) return 0;
+ const int s = i >> 31;
+ i |= (1L<<23);
+ i &= ~0xFF000000;
+ return s ? -i : i;
+}
+
+GLfloat clampToZerof(GLfloat v) {
+#if DEBUG_USE_FLOATS
+ return v<0 ? 0 : (v>1 ? 1 : v);
+#else
+ union {
+ float f;
+ int32_t i;
+ };
+ f = v;
+ i &= ~(i>>31);
+ return f;
+#endif
+}
+
+GLfloat reciprocalf(GLfloat v) {
+ // XXX: do better
+ return 1.0f / v;
+}
+
+GLfloat rsqrtf(GLfloat v) {
+ // XXX: do better
+ return 1.0f / sqrtf(v);
+}
+
+GLfloat sqrf(GLfloat v) {
+ // XXX: do better
+ return v*v;
+}
+
+GLfloat addExpf(GLfloat v, int e) {
+ union {
+ float f;
+ int32_t i;
+ };
+ f = v;
+ if (i<<1) { // XXX: deal with over/underflow
+ i += int32_t(e)<<23;
+ }
+ return f;
+}
+
+GLfloat mul2f(GLfloat v) {
+#if DEBUG_USE_FLOATS
+ return v*2;
+#else
+ return addExpf(v, 1);
+#endif
+}
+
+GLfloat div2f(GLfloat v) {
+#if DEBUG_USE_FLOATS
+ return v*0.5f;
+#else
+ return addExpf(v, -1);
+#endif
+}
+
+GLfloat absf(GLfloat v) {
+#if DEBUG_USE_FLOATS
+ return v<0 ? -v : v;
+#else
+ union {
+ float f;
+ int32_t i;
+ };
+ f = v;
+ i &= ~0x80000000;
+ return f;
+#endif
+}
+
+}; // namespace gl
+
+// ----------------------------------------------------------------------------
+}; // namespace android
+
+#endif // ANDROID_OPENGLES_FP_H
+
diff --git a/opengl/libagl/iterators.S b/opengl/libagl/iterators.S
new file mode 100644
index 0000000..daf2937
--- /dev/null
+++ b/opengl/libagl/iterators.S
@@ -0,0 +1,88 @@
+/* libs/opengles/iterators.S
+**
+** Copyright 2006, 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.
+*/
+
+
+ .text
+ .align
+ .arm
+
+ .global iterators0032
+
+/*
+ * iterators0032
+ *
+ * MUST BE CALLED FROM ARM CODE
+ *
+ * r0: const compute_iterators_t* (this)
+ * r0 + 0: m_dx01
+ * r0 + 4: m_dy10
+ * r0 + 8: m_dx20
+ * r0 +12: m_dy02
+ * r0 +16: m_x0
+ * r0 +20: m_y0
+ * r0 +24: m_area
+ * r0 +28: m_scale
+ * r0 +29: m_area_scale;
+ * r1: int32_t* (out)
+ * r1 + 0: c
+ * r1 + 4: dcdx
+ * r1 + 8: dcdy
+ * r2: c0
+ * r3: c1
+ * [sp]: c2
+ */
+
+iterators0032:
+ stmfd sp!, {r4, r5, r6, r7, r8, lr}
+ ldr r4, [sp, #4*6]
+
+ ldrb r12, [r0, #29]
+ sub r3, r3, r2
+ sub r4, r4, r2
+ sub r12, r12, #16
+ mov r3, r3, asr r12
+ mov r4, r4, asr r12
+
+ ldr r5, [r0, #0]
+ ldr r12, [r0, #4]
+ smull r8, lr, r4, r5
+ ldr r5, [r0, #8]
+ smull r6, r7, r4, r12
+ ldr r12, [r0, #12]
+ smlal r8, lr, r3, r5
+ smlal r6, r7, r3, r12
+
+ ldr r3, [r0, #16] // m_x0
+ ldr r4, [r0, #20] // m_x1
+
+ str r6, [r1, #4]
+ str r8, [r1, #8]
+
+ umull r6, r5, r3, r6
+ umull r8, r0, r4, r8
+ mla r7, r3, r7, r5
+ mla lr, r4, lr, r0
+ adds r6, r6, r8
+ adc r7, r7, lr
+
+ movs r6, r6, lsr #4
+ adc r6, r6, r7, lsl #28
+ rsb r6, r6, r2, lsl #16
+ str r6, [r1, #0]
+
+ ldmfd sp!, {r4, r5, r6, r7, r8, pc}
+
diff --git a/opengl/libagl/light.cpp b/opengl/libagl/light.cpp
new file mode 100644
index 0000000..25c41d0
--- /dev/null
+++ b/opengl/libagl/light.cpp
@@ -0,0 +1,852 @@
+/* libs/opengles/light.cpp
+**
+** Copyright 2006, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+** http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+#include <stdio.h>
+#include "context.h"
+#include "fp.h"
+#include "light.h"
+#include "state.h"
+#include "matrix.h"
+
+
+#if defined(__arm__) && defined(__thumb__)
+#warning "light.cpp should not be compiled in thumb on ARM."
+#endif
+
+namespace android {
+
+// ----------------------------------------------------------------------------
+
+static void invalidate_lighting(ogles_context_t* c);
+static void lightVertexValidate(ogles_context_t* c, vertex_t* v);
+static void lightVertexNop(ogles_context_t* c, vertex_t* v);
+static void lightVertex(ogles_context_t* c, vertex_t* v);
+static void lightVertexMaterial(ogles_context_t* c, vertex_t* v);
+
+static inline void vscale3(GLfixed* d, const GLfixed* m, GLfixed s);
+static inline void vsub3w(GLfixed* d, const GLfixed* a, const GLfixed* b);
+
+static __attribute__((noinline))
+void vnorm3(GLfixed* d, const GLfixed* a);
+
+static inline void vsa3(GLfixed* d,
+ const GLfixed* m, GLfixed s, const GLfixed* a);
+static inline void vmla3(GLfixed* d,
+ const GLfixed* m0, const GLfixed* m1, const GLfixed* a);
+static inline void vmul3(GLfixed* d,
+ const GLfixed* m0, const GLfixed* m1);
+
+static GLfixed fog_linear(ogles_context_t* c, GLfixed z);
+static GLfixed fog_exp(ogles_context_t* c, GLfixed z);
+static GLfixed fog_exp2(ogles_context_t* c, GLfixed z);
+
+
+// ----------------------------------------------------------------------------
+
+static void init_white(vec4_t& c) {
+ c.r = c.g = c.b = c.a = 0x10000;
+}
+
+void ogles_init_light(ogles_context_t* c)
+{
+ for (unsigned int i=0 ; i<OGLES_MAX_LIGHTS ; i++) {
+ c->lighting.lights[i].ambient.a = 0x10000;
+ c->lighting.lights[i].position.z = 0x10000;
+ c->lighting.lights[i].spotDir.z = -0x10000;
+ c->lighting.lights[i].spotCutoff = gglIntToFixed(180);
+ c->lighting.lights[i].attenuation[0] = 0x10000;
+ }
+ init_white(c->lighting.lights[0].diffuse);
+ init_white(c->lighting.lights[0].specular);
+
+ c->lighting.front.ambient.r =
+ c->lighting.front.ambient.g =
+ c->lighting.front.ambient.b = gglFloatToFixed(0.2f);
+ c->lighting.front.ambient.a = 0x10000;
+ c->lighting.front.diffuse.r =
+ c->lighting.front.diffuse.g =
+ c->lighting.front.diffuse.b = gglFloatToFixed(0.8f);
+ c->lighting.front.diffuse.a = 0x10000;
+ c->lighting.front.specular.a = 0x10000;
+ c->lighting.front.emission.a = 0x10000;
+
+ c->lighting.lightModel.ambient.r =
+ c->lighting.lightModel.ambient.g =
+ c->lighting.lightModel.ambient.b = gglFloatToFixed(0.2f);
+ c->lighting.lightModel.ambient.a = 0x10000;
+
+ c->lighting.colorMaterial.face = GL_FRONT_AND_BACK;
+ c->lighting.colorMaterial.mode = GL_AMBIENT_AND_DIFFUSE;
+
+ c->fog.mode = GL_EXP;
+ c->fog.fog = fog_exp;
+ c->fog.density = 0x10000;
+ c->fog.end = 0x10000;
+ c->fog.invEndMinusStart = 0x10000;
+
+ invalidate_lighting(c);
+
+ c->rasterizer.procs.shadeModel(c, GL_SMOOTH);
+ c->lighting.shadeModel = GL_SMOOTH;
+}
+
+void ogles_uninit_light(ogles_context_t* c)
+{
+}
+
+static inline int32_t clampF(GLfixed f) CONST;
+int32_t clampF(GLfixed f) {
+ f = (f & ~(f>>31));
+ if (f >= 0x10000)
+ f = 0x10000;
+ return f;
+}
+
+static GLfixed fog_linear(ogles_context_t* c, GLfixed z) {
+ return clampF(gglMulx((c->fog.end - ((z<0)?-z:z)), c->fog.invEndMinusStart));
+}
+
+static GLfixed fog_exp(ogles_context_t* c, GLfixed z) {
+ const float e = fixedToFloat(gglMulx(c->fog.density, ((z<0)?-z:z)));
+ return clampF(gglFloatToFixed(fastexpf(-e)));
+}
+
+static GLfixed fog_exp2(ogles_context_t* c, GLfixed z) {
+ const float e = fixedToFloat(gglMulx(c->fog.density, z));
+ return clampF(gglFloatToFixed(fastexpf(-e*e)));
+}
+
+// ----------------------------------------------------------------------------
+#if 0
+#pragma mark -
+#pragma mark math helpers
+#endif
+
+static inline
+void vscale3(GLfixed* d, const GLfixed* m, GLfixed s) {
+ d[0] = gglMulx(m[0], s);
+ d[1] = gglMulx(m[1], s);
+ d[2] = gglMulx(m[2], s);
+}
+
+static inline
+void vsa3(GLfixed* d, const GLfixed* m, GLfixed s, const GLfixed* a) {
+ d[0] = gglMulAddx(m[0], s, a[0]);
+ d[1] = gglMulAddx(m[1], s, a[1]);
+ d[2] = gglMulAddx(m[2], s, a[2]);
+}
+
+static inline
+void vsub3w(GLfixed* d, const GLfixed* a, const GLfixed* b) {
+ const GLfixed wa = a[3];
+ const GLfixed wb = b[3];
+ if (ggl_likely(wa == wb)) {
+ d[0] = a[0] - b[0];
+ d[1] = a[1] - b[1];
+ d[2] = a[2] - b[2];
+ } else {
+ d[0] = gglMulSubx(a[0], wb, gglMulx(b[0], wa));
+ d[1] = gglMulSubx(a[1], wb, gglMulx(b[1], wa));
+ d[2] = gglMulSubx(a[2], wb, gglMulx(b[2], wa));
+ }
+}
+
+static inline
+void vmla3(GLfixed* d,
+ const GLfixed* m0, const GLfixed* m1, const GLfixed* a)
+{
+ d[0] = gglMulAddx(m0[0], m1[0], a[0]);
+ d[1] = gglMulAddx(m0[1], m1[1], a[1]);
+ d[2] = gglMulAddx(m0[2], m1[2], a[2]);
+}
+
+static inline
+void vmul3(GLfixed* d, const GLfixed* m0, const GLfixed* m1) {
+ d[0] = gglMulx(m0[0], m1[0]);
+ d[1] = gglMulx(m0[1], m1[1]);
+ d[2] = gglMulx(m0[2], m1[2]);
+}
+
+void vnorm3(GLfixed* d, const GLfixed* a)
+{
+ // we must take care of overflows when normalizing a vector
+ GLfixed n;
+ int32_t x = a[0]; x = x>=0 ? x : -x;
+ int32_t y = a[1]; y = y>=0 ? y : -y;
+ int32_t z = a[2]; z = z>=0 ? z : -z;
+ if (ggl_likely(x<=0x6800 && y<=0x6800 && z<= 0x6800)) {
+ // in this case this will all fit on 32 bits
+ n = x*x + y*y + z*z;
+ n = gglSqrtRecipx(n);
+ n <<= 8;
+ } else {
+ // here norm^2 is at least 0x7EC00000 (>>32 == 0.495117)
+ n = vsquare3(x, y, z);
+ n = gglSqrtRecipx(n);
+ }
+ vscale3(d, a, n);
+}
+
+// ----------------------------------------------------------------------------
+#if 0
+#pragma mark -
+#pragma mark lighting equations
+#endif
+
+static inline void light_picker(ogles_context_t* c)
+{
+ if (ggl_likely(!c->lighting.enable)) {
+ c->lighting.lightVertex = lightVertexNop;
+ return;
+ }
+ if (c->lighting.colorMaterial.enable) {
+ c->lighting.lightVertex = lightVertexMaterial;
+ } else {
+ c->lighting.lightVertex = lightVertex;
+ }
+}
+
+static inline void validate_light_mvi(ogles_context_t* c)
+{
+ uint32_t en = c->lighting.enabledLights;
+ while (en) {
+ const int i = 31 - gglClz(en);
+ en &= ~(1<<i);
+ light_t& l = c->lighting.lights[i];
+ c->transforms.mvui.point3(&c->transforms.mvui,
+ &l.objPosition, &l.position);
+ vnorm3(l.normalizedObjPosition.v, l.objPosition.v);
+ }
+}
+
+static inline void validate_light(ogles_context_t* c)
+{
+ // if colorMaterial is enabled, we get the color from the vertex
+ if (!c->lighting.colorMaterial.enable) {
+ material_t& material = c->lighting.front;
+ uint32_t en = c->lighting.enabledLights;
+ while (en) {
+ const int i = 31 - gglClz(en);
+ en &= ~(1<<i);
+ light_t& l = c->lighting.lights[i];
+ vmul3(l.implicitAmbient.v, material.ambient.v, l.ambient.v);
+ vmul3(l.implicitDiffuse.v, material.diffuse.v, l.diffuse.v);
+ vmul3(l.implicitSpecular.v, material.specular.v, l.specular.v);
+
+ // this is just a flag to tell if we have a specular component
+ l.implicitSpecular.v[3] =
+ l.implicitSpecular.r |
+ l.implicitSpecular.g |
+ l.implicitSpecular.b;
+
+ l.rConstAttenuation = (l.attenuation[1] | l.attenuation[2])==0;
+ if (l.rConstAttenuation)
+ l.rConstAttenuation = gglRecipFast(l.attenuation[0]);
+ }
+ // emission and ambient for the whole scene
+ vmla3( c->lighting.implicitSceneEmissionAndAmbient.v,
+ c->lighting.lightModel.ambient.v,
+ material.ambient.v,
+ material.emission.v);
+ c->lighting.implicitSceneEmissionAndAmbient.a = material.diffuse.a;
+ }
+ validate_light_mvi(c);
+}
+
+void invalidate_lighting(ogles_context_t* c)
+{
+ // TODO: pick lightVertexValidate or lightVertexValidateMVI
+ // instead of systematically the heavier lightVertexValidate()
+ c->lighting.lightVertex = lightVertexValidate;
+}
+
+void ogles_invalidate_lighting_mvui(ogles_context_t* c)
+{
+ invalidate_lighting(c);
+}
+
+void lightVertexNop(ogles_context_t*, vertex_t* v)
+{
+ // we should never end-up here
+}
+
+void lightVertexValidateMVI(ogles_context_t* c, vertex_t* v)
+{
+ validate_light_mvi(c);
+ light_picker(c);
+ c->lighting.lightVertex(c, v);
+}
+
+void lightVertexValidate(ogles_context_t* c, vertex_t* v)
+{
+ validate_light(c);
+ light_picker(c);
+ c->lighting.lightVertex(c, v);
+}
+
+void lightVertexMaterial(ogles_context_t* c, vertex_t* v)
+{
+ // fetch the material color
+ const GLvoid* cp = c->arrays.color.element(
+ v->index & vertex_cache_t::INDEX_MASK);
+ c->arrays.color.fetch(c, v->color.v, cp);
+
+ // acquire the color-material from the vertex
+ material_t& material = c->lighting.front;
+ material.ambient =
+ material.diffuse = v->color;
+ // implicit arguments need to be computed per/vertex
+ uint32_t en = c->lighting.enabledLights;
+ while (en) {
+ const int i = 31 - gglClz(en);
+ en &= ~(1<<i);
+ light_t& l = c->lighting.lights[i];
+ vmul3(l.implicitAmbient.v, material.ambient.v, l.ambient.v);
+ vmul3(l.implicitDiffuse.v, material.diffuse.v, l.diffuse.v);
+ vmul3(l.implicitSpecular.v, material.specular.v, l.specular.v);
+ }
+ // emission and ambient for the whole scene
+ vmla3( c->lighting.implicitSceneEmissionAndAmbient.v,
+ c->lighting.lightModel.ambient.v,
+ material.ambient.v,
+ material.emission.v);
+ c->lighting.implicitSceneEmissionAndAmbient.a = material.diffuse.a;
+
+ // now we can light our vertex as usual
+ lightVertex(c, v);
+}
+
+void lightVertex(ogles_context_t* c, vertex_t* v)
+{
+ // emission and ambient for the whole scene
+ vec4_t r = c->lighting.implicitSceneEmissionAndAmbient;
+
+ uint32_t en = c->lighting.enabledLights;
+ if (ggl_likely(en)) {
+ // since we do the lighting in object-space, we don't need to
+ // transform each normal. However, we might still have to normalize
+ // it if GL_NORMALIZE is enabled.
+ vec4_t n;
+ c->arrays.normal.fetch(c, n.v,
+ c->arrays.normal.element(v->index & vertex_cache_t::INDEX_MASK));
+ if (c->transforms.rescaleNormals == GL_NORMALIZE)
+ vnorm3(n.v, n.v);
+
+ const material_t& material = c->lighting.front;
+ const int twoSide = c->lighting.lightModel.twoSide;
+
+ while (en) {
+ const int i = 31 - gglClz(en);
+ en &= ~(1<<i);
+ const light_t& l = c->lighting.lights[i];
+
+ vec4_t d, t;
+ GLfixed s;
+ GLfixed sqDist = 0x10000;
+
+ // compute vertex-to-light vector
+ if (ggl_unlikely(l.position.w)) {
+ vsub3w(d.v, l.objPosition.v, v->obj.v);
+ sqDist = dot3(d.v, d.v);
+ vscale3(d.v, d.v, gglSqrtRecipx(sqDist));
+ } else {
+ // TODO: avoid copy here
+ d = l.normalizedObjPosition;
+ }
+
+ // ambient & diffuse
+ s = dot3(n.v, d.v);
+ s = (s<0) ? (twoSide?(-s):0) : s;
+ vsa3(t.v, l.implicitDiffuse.v, s, l.implicitAmbient.v);
+
+ // specular
+ if (ggl_unlikely(s && l.implicitSpecular.v[3])) {
+ vec4_t h;
+ h.x = d.x;
+ h.y = d.y;
+ h.z = d.z + 0x10000;
+ vnorm3(h.v, h.v);
+ s = dot3(n.v, h.v);
+ s = (s<0) ? (twoSide?(-s):0) : s;
+ if (s > 0) {
+ s = gglPowx(s, material.shininess);
+ vsa3(t.v, l.implicitSpecular.v, s, t.v);
+ }
+ }
+
+ // spot
+ if (ggl_unlikely(l.spotCutoff != gglIntToFixed(180))) {
+ GLfixed spotAtt = -dot3(l.normalizedSpotDir.v, d.v);
+ if (spotAtt >= l.spotCutoffCosine) {
+ vscale3(t.v, t.v, gglPowx(spotAtt, l.spotExp));
+ }
+ }
+
+ // attenuation
+ if (ggl_unlikely(l.position.w)) {
+ if (l.rConstAttenuation) {
+ s = l.rConstAttenuation;
+ } else {
+ s = gglMulAddx(sqDist, l.attenuation[2], l.attenuation[0]);
+ if (l.attenuation[1])
+ s = gglMulAddx(gglSqrtx(sqDist), l.attenuation[1], s);
+ s = gglRecipFast(s);
+ }
+ vscale3(t.v, t.v, s);
+ }
+
+ r.r += t.r;
+ r.g += t.g;
+ r.b += t.b;
+ }
+ }
+ v->color.r = gglClampx(r.r);
+ v->color.g = gglClampx(r.g);
+ v->color.b = gglClampx(r.b);
+ v->color.a = gglClampx(r.a);
+ v->flags |= vertex_t::LIT;
+}
+
+static void lightModelx(GLenum pname, GLfixed param, ogles_context_t* c)
+{
+ if (ggl_unlikely(pname != GL_LIGHT_MODEL_TWO_SIDE)) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ c->lighting.lightModel.twoSide = param ? GL_TRUE : GL_FALSE;
+ invalidate_lighting(c);
+}
+
+static void lightx(GLenum i, GLenum pname, GLfixed param, ogles_context_t* c)
+{
+ if (ggl_unlikely(uint32_t(i-GL_LIGHT0) >= OGLES_MAX_LIGHTS)) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+
+ light_t& light = c->lighting.lights[i-GL_LIGHT0];
+ const GLfixed kDegToRad = GLfixed((M_PI * gglIntToFixed(1)) / 180.0f);
+ switch (pname) {
+ case GL_SPOT_EXPONENT:
+ if (GGLfixed(param) >= gglIntToFixed(128)) {
+ ogles_error(c, GL_INVALID_VALUE);
+ return;
+ }
+ light.spotExp = param;
+ break;
+ case GL_SPOT_CUTOFF:
+ if (param!=gglIntToFixed(180) && GGLfixed(param)>=gglIntToFixed(90)) {
+ ogles_error(c, GL_INVALID_VALUE);
+ return;
+ }
+ light.spotCutoff = param;
+ light.spotCutoffCosine =
+ gglFloatToFixed(cosinef((M_PI/(180.0f*65536.0f))*param));
+ break;
+ case GL_CONSTANT_ATTENUATION:
+ if (param < 0) {
+ ogles_error(c, GL_INVALID_VALUE);
+ return;
+ }
+ light.attenuation[0] = param;
+ break;
+ case GL_LINEAR_ATTENUATION:
+ if (param < 0) {
+ ogles_error(c, GL_INVALID_VALUE);
+ return;
+ }
+ light.attenuation[1] = param;
+ break;
+ case GL_QUADRATIC_ATTENUATION:
+ if (param < 0) {
+ ogles_error(c, GL_INVALID_VALUE);
+ return;
+ }
+ light.attenuation[2] = param;
+ break;
+ default:
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ invalidate_lighting(c);
+}
+
+static void lightxv(GLenum i, GLenum pname, const GLfixed *params, ogles_context_t* c)
+{
+ if (ggl_unlikely(uint32_t(i-GL_LIGHT0) >= OGLES_MAX_LIGHTS)) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+
+ GLfixed* what;
+ light_t& light = c->lighting.lights[i-GL_LIGHT0];
+ switch (pname) {
+ case GL_AMBIENT:
+ what = light.ambient.v;
+ break;
+ case GL_DIFFUSE:
+ what = light.diffuse.v;
+ break;
+ case GL_SPECULAR:
+ what = light.specular.v;
+ break;
+ case GL_POSITION: {
+ ogles_validate_transform(c, transform_state_t::MODELVIEW);
+ transform_t& mv = c->transforms.modelview.transform;
+ memcpy(light.position.v, params, sizeof(light.position.v));
+ mv.point4(&mv, &light.position, &light.position);
+ invalidate_lighting(c);
+ return;
+ }
+ case GL_SPOT_DIRECTION: {
+ ogles_validate_transform(c, transform_state_t::MVUI);
+ transform_t& mvui = c->transforms.mvui;
+ mvui.point3(&mvui, &light.spotDir, (vec4_t*)params);
+ vnorm3(light.normalizedSpotDir.v, light.spotDir.v);
+ invalidate_lighting(c);
+ return;
+ }
+ default:
+ lightx(i, pname, params[0], c);
+ return;
+ }
+ what[0] = params[0];
+ what[1] = params[1];
+ what[2] = params[2];
+ what[3] = params[3];
+ invalidate_lighting(c);
+}
+
+static void materialx(GLenum face, GLenum pname, GLfixed param, ogles_context_t* c)
+{
+ if (ggl_unlikely(face != GL_FRONT_AND_BACK)) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ if (ggl_unlikely(pname != GL_SHININESS)) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ c->lighting.front.shininess = param;
+ invalidate_lighting(c);
+}
+
+static void fogx(GLenum pname, GLfixed param, ogles_context_t* c)
+{
+ switch (pname) {
+ case GL_FOG_DENSITY:
+ if (param >= 0) {
+ c->fog.density = param;
+ break;
+ }
+ ogles_error(c, GL_INVALID_VALUE);
+ break;
+ case GL_FOG_START:
+ c->fog.start = param;
+ c->fog.invEndMinusStart = gglRecip(c->fog.end - c->fog.start);
+ break;
+ case GL_FOG_END:
+ c->fog.end = param;
+ c->fog.invEndMinusStart = gglRecip(c->fog.end - c->fog.start);
+ break;
+ case GL_FOG_MODE:
+ switch (param) {
+ case GL_LINEAR:
+ c->fog.mode = param;
+ c->fog.fog = fog_linear;
+ break;
+ case GL_EXP:
+ c->fog.mode = param;
+ c->fog.fog = fog_exp;
+ break;
+ case GL_EXP2:
+ c->fog.mode = param;
+ c->fog.fog = fog_exp2;
+ break;
+ default:
+ ogles_error(c, GL_INVALID_ENUM);
+ break;
+ }
+ break;
+ default:
+ ogles_error(c, GL_INVALID_ENUM);
+ break;
+ }
+}
+
+// ----------------------------------------------------------------------------
+}; // namespace android
+// ----------------------------------------------------------------------------
+
+using namespace android;
+
+#if 0
+#pragma mark -
+#pragma mark lighting APIs
+#endif
+
+void glShadeModel(GLenum mode)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if (ggl_unlikely(mode != GL_SMOOTH && mode != GL_FLAT)) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ c->lighting.shadeModel = mode;
+}
+
+void glLightModelf(GLenum pname, GLfloat param)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ lightModelx(pname, gglFloatToFixed(param), c);
+}
+
+void glLightModelx(GLenum pname, GLfixed param)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ lightModelx(pname, param, c);
+}
+
+void glLightModelfv(GLenum pname, const GLfloat *params)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if (pname == GL_LIGHT_MODEL_TWO_SIDE) {
+ lightModelx(pname, gglFloatToFixed(params[0]), c);
+ return;
+ }
+
+ if (ggl_unlikely(pname != GL_LIGHT_MODEL_AMBIENT)) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+
+ c->lighting.lightModel.ambient.r = gglFloatToFixed(params[0]);
+ c->lighting.lightModel.ambient.g = gglFloatToFixed(params[1]);
+ c->lighting.lightModel.ambient.b = gglFloatToFixed(params[2]);
+ c->lighting.lightModel.ambient.a = gglFloatToFixed(params[3]);
+ invalidate_lighting(c);
+}
+
+void glLightModelxv(GLenum pname, const GLfixed *params)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if (pname == GL_LIGHT_MODEL_TWO_SIDE) {
+ lightModelx(pname, params[0], c);
+ return;
+ }
+
+ if (ggl_unlikely(pname != GL_LIGHT_MODEL_AMBIENT)) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+
+ c->lighting.lightModel.ambient.r = params[0];
+ c->lighting.lightModel.ambient.g = params[1];
+ c->lighting.lightModel.ambient.b = params[2];
+ c->lighting.lightModel.ambient.a = params[3];
+ invalidate_lighting(c);
+}
+
+// ----------------------------------------------------------------------------
+#if 0
+#pragma mark -
+#endif
+
+void glLightf(GLenum i, GLenum pname, GLfloat param)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ lightx(i, pname, gglFloatToFixed(param), c);
+}
+
+void glLightx(GLenum i, GLenum pname, GLfixed param)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ lightx(i, pname, param, c);
+}
+
+void glLightfv(GLenum i, GLenum pname, const GLfloat *params)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ switch (pname) {
+ case GL_SPOT_EXPONENT:
+ case GL_SPOT_CUTOFF:
+ case GL_CONSTANT_ATTENUATION:
+ case GL_LINEAR_ATTENUATION:
+ case GL_QUADRATIC_ATTENUATION:
+ lightx(i, pname, gglFloatToFixed(params[0]), c);
+ return;
+ }
+
+ GLfixed paramsx[4];
+ paramsx[0] = gglFloatToFixed(params[0]);
+ paramsx[1] = gglFloatToFixed(params[1]);
+ paramsx[2] = gglFloatToFixed(params[2]);
+ if (pname != GL_SPOT_DIRECTION)
+ paramsx[3] = gglFloatToFixed(params[3]);
+
+ lightxv(i, pname, paramsx, c);
+}
+
+void glLightxv(GLenum i, GLenum pname, const GLfixed *params)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ lightxv(i, pname, params, c);
+}
+
+// ----------------------------------------------------------------------------
+#if 0
+#pragma mark -
+#endif
+
+void glMaterialf(GLenum face, GLenum pname, GLfloat param)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ materialx(face, pname, gglFloatToFixed(param), c);
+}
+
+void glMaterialx(GLenum face, GLenum pname, GLfixed param)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ materialx(face, pname, param, c);
+}
+
+void glMaterialfv(
+ GLenum face, GLenum pname, const GLfloat *params)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if (ggl_unlikely(face != GL_FRONT_AND_BACK)) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ GLfixed* what=0;
+ GLfixed* other=0;
+ switch (pname) {
+ case GL_AMBIENT: what = c->lighting.front.ambient.v; break;
+ case GL_DIFFUSE: what = c->lighting.front.diffuse.v; break;
+ case GL_SPECULAR: what = c->lighting.front.specular.v; break;
+ case GL_EMISSION: what = c->lighting.front.emission.v; break;
+ case GL_AMBIENT_AND_DIFFUSE:
+ what = c->lighting.front.ambient.v; break;
+ other = c->lighting.front.diffuse.v; break;
+ break;
+ case GL_SHININESS:
+ c->lighting.front.shininess = gglFloatToFixed(params[0]);
+ invalidate_lighting(c);
+ return;
+ default:
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ what[0] = gglFloatToFixed(params[0]);
+ what[1] = gglFloatToFixed(params[1]);
+ what[2] = gglFloatToFixed(params[2]);
+ what[3] = gglFloatToFixed(params[3]);
+ if (other) {
+ other[0] = what[0];
+ other[1] = what[1];
+ other[2] = what[2];
+ other[3] = what[3];
+ }
+ invalidate_lighting(c);
+}
+
+void glMaterialxv(
+ GLenum face, GLenum pname, const GLfixed *params)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if (ggl_unlikely(face != GL_FRONT_AND_BACK)) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ GLfixed* what=0;
+ GLfixed* other=0;
+ switch (pname) {
+ case GL_AMBIENT: what = c->lighting.front.ambient.v; break;
+ case GL_DIFFUSE: what = c->lighting.front.diffuse.v; break;
+ case GL_SPECULAR: what = c->lighting.front.specular.v; break;
+ case GL_EMISSION: what = c->lighting.front.emission.v; break;
+ case GL_AMBIENT_AND_DIFFUSE:
+ what = c->lighting.front.ambient.v; break;
+ other= c->lighting.front.diffuse.v; break;
+ break;
+ case GL_SHININESS:
+ c->lighting.front.shininess = gglFloatToFixed(params[0]);
+ invalidate_lighting(c);
+ return;
+ default:
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ what[0] = params[0];
+ what[1] = params[1];
+ what[2] = params[2];
+ what[3] = params[3];
+ if (other) {
+ other[0] = what[0];
+ other[1] = what[1];
+ other[2] = what[2];
+ other[3] = what[3];
+ }
+ invalidate_lighting(c);
+}
+
+// ----------------------------------------------------------------------------
+#if 0
+#pragma mark -
+#pragma mark fog
+#endif
+
+void glFogf(GLenum pname, GLfloat param) {
+ ogles_context_t* c = ogles_context_t::get();
+ GLfixed paramx = (GLfixed)param;
+ if (pname != GL_FOG_MODE)
+ paramx = gglFloatToFixed(param);
+ fogx(pname, paramx, c);
+}
+
+void glFogx(GLenum pname, GLfixed param) {
+ ogles_context_t* c = ogles_context_t::get();
+ fogx(pname, param, c);
+}
+
+void glFogfv(GLenum pname, const GLfloat *params)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if (pname != GL_FOG_COLOR) {
+ GLfixed paramx = (GLfixed)params[0];
+ if (pname != GL_FOG_MODE)
+ paramx = gglFloatToFixed(params[0]);
+ fogx(pname, paramx, c);
+ return;
+ }
+ GLfixed paramsx[4];
+ paramsx[0] = gglFloatToFixed(params[0]);
+ paramsx[1] = gglFloatToFixed(params[1]);
+ paramsx[2] = gglFloatToFixed(params[2]);
+ paramsx[3] = gglFloatToFixed(params[3]);
+ c->rasterizer.procs.fogColor3xv(c, paramsx);
+}
+
+void glFogxv(GLenum pname, const GLfixed *params)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if (pname != GL_FOG_COLOR) {
+ fogx(pname, params[0], c);
+ return;
+ }
+ c->rasterizer.procs.fogColor3xv(c, params);
+}
diff --git a/opengl/libagl/light.h b/opengl/libagl/light.h
new file mode 100644
index 0000000..6dae25f
--- /dev/null
+++ b/opengl/libagl/light.h
@@ -0,0 +1,38 @@
+/* libs/opengles/light.h
+**
+** Copyright 2006, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+** http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+#ifndef ANDROID_OPENGLES_LIGHT_H
+#define ANDROID_OPENGLES_LIGHT_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include <sys/types.h>
+
+namespace android {
+
+namespace gl {
+struct ogles_context_t;
+};
+
+void ogles_init_light(ogles_context_t* c);
+void ogles_uninit_light(ogles_context_t* c);
+void ogles_invalidate_lighting_mvui(ogles_context_t* c);
+
+}; // namespace android
+
+#endif // ANDROID_OPENGLES_LIGHT_H
+
diff --git a/opengl/libagl/matrix.cpp b/opengl/libagl/matrix.cpp
new file mode 100644
index 0000000..f175cda
--- /dev/null
+++ b/opengl/libagl/matrix.cpp
@@ -0,0 +1,1145 @@
+/* libs/opengles/matrix.cpp
+**
+** Copyright 2006, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+** http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+#include <stdlib.h>
+#include <stdio.h>
+
+#include "context.h"
+#include "fp.h"
+#include "state.h"
+#include "matrix.h"
+#include "vertex.h"
+#include "light.h"
+
+#if defined(__arm__) && defined(__thumb__)
+#warning "matrix.cpp should not be compiled in thumb on ARM."
+#endif
+
+#define I(_i, _j) ((_j)+ 4*(_i))
+
+namespace android {
+
+// ----------------------------------------------------------------------------
+
+static const GLfloat gIdentityf[16] = { 1,0,0,0,
+ 0,1,0,0,
+ 0,0,1,0,
+ 0,0,0,1 };
+
+static const matrixx_t gIdentityx = {
+ { 0x10000,0,0,0,
+ 0,0x10000,0,0,
+ 0,0,0x10000,0,
+ 0,0,0,0x10000
+ }
+ };
+
+static void point2__nop(transform_t const*, vec4_t* c, vec4_t const* o);
+static void point3__nop(transform_t const*, vec4_t* c, vec4_t const* o);
+static void point4__nop(transform_t const*, vec4_t* c, vec4_t const* o);
+static void normal__nop(transform_t const*, vec4_t* c, vec4_t const* o);
+static void point2__generic(transform_t const*, vec4_t* c, vec4_t const* o);
+static void point3__generic(transform_t const*, vec4_t* c, vec4_t const* o);
+static void point4__generic(transform_t const*, vec4_t* c, vec4_t const* o);
+static void normal__generic(transform_t const*, vec4_t* c, vec4_t const* o);
+
+// ----------------------------------------------------------------------------
+#if 0
+#pragma mark -
+#endif
+
+void ogles_init_matrix(ogles_context_t* c)
+{
+ c->transforms.modelview.init(OGLES_MODELVIEW_STACK_DEPTH);
+ c->transforms.projection.init(OGLES_PROJECTION_STACK_DEPTH);
+ for (int i=0; i<GGL_TEXTURE_UNIT_COUNT ; i++)
+ c->transforms.texture[i].init(OGLES_TEXTURE_STACK_DEPTH);
+
+ c->transforms.current = &c->transforms.modelview;
+ c->transforms.matrixMode = GL_MODELVIEW;
+ c->transforms.dirty = transform_state_t::VIEWPORT |
+ transform_state_t::MVUI |
+ transform_state_t::MVIT |
+ transform_state_t::MVP;
+ c->transforms.mvp.loadIdentity();
+ c->transforms.mvp4.loadIdentity();
+ c->transforms.mvit4.loadIdentity();
+ c->transforms.mvui.loadIdentity();
+ c->transforms.vpt.loadIdentity();
+ c->transforms.vpt.zNear = 0.0f;
+ c->transforms.vpt.zFar = 1.0f;
+}
+
+void ogles_uninit_matrix(ogles_context_t* c)
+{
+ c->transforms.modelview.uninit();
+ c->transforms.projection.uninit();
+ for (int i=0; i<GGL_TEXTURE_UNIT_COUNT ; i++)
+ c->transforms.texture[i].uninit();
+}
+
+static void validate_perspective(ogles_context_t* c, vertex_t* v)
+{
+ const uint32_t enables = c->rasterizer.state.enables;
+ c->arrays.perspective = (c->clipPlanes.enable) ?
+ ogles_vertex_clipAllPerspective3D : ogles_vertex_perspective3D;
+ if (enables & (GGL_ENABLE_DEPTH_TEST|GGL_ENABLE_FOG)) {
+ c->arrays.perspective = ogles_vertex_perspective3DZ;
+ if (c->clipPlanes.enable || (enables&GGL_ENABLE_FOG))
+ c->arrays.perspective = ogles_vertex_clipAllPerspective3DZ;
+ }
+ if ((c->arrays.vertex.size != 4) &&
+ (c->transforms.mvp4.flags & transform_t::FLAGS_2D_PROJECTION)) {
+ c->arrays.perspective = ogles_vertex_perspective2D;
+ }
+ c->arrays.perspective(c, v);
+}
+
+void ogles_invalidate_perspective(ogles_context_t* c)
+{
+ c->arrays.perspective = validate_perspective;
+}
+
+void ogles_validate_transform_impl(ogles_context_t* c, uint32_t want)
+{
+ int dirty = c->transforms.dirty & want;
+
+ // Validate the modelview
+ if (dirty & transform_state_t::MODELVIEW) {
+ c->transforms.modelview.validate();
+ }
+
+ // Validate the projection stack (in fact, it's never needed)
+ if (dirty & transform_state_t::PROJECTION) {
+ c->transforms.projection.validate();
+ }
+
+ // Validate the viewport transformation
+ if (dirty & transform_state_t::VIEWPORT) {
+ vp_transform_t& vpt = c->transforms.vpt;
+ vpt.transform.matrix.load(vpt.matrix);
+ vpt.transform.picker();
+ }
+
+ // We need to update the mvp (used to transform each vertex)
+ if (dirty & transform_state_t::MVP) {
+ c->transforms.update_mvp();
+ // invalidate perspective (divide by W) and view volume clipping
+ ogles_invalidate_perspective(c);
+ }
+
+ // Validate the mvui (for normal transformation)
+ if (dirty & transform_state_t::MVUI) {
+ c->transforms.update_mvui();
+ ogles_invalidate_lighting_mvui(c);
+ }
+
+ // Validate the texture stack
+ if (dirty & transform_state_t::TEXTURE) {
+ for (int i=0; i<GGL_TEXTURE_UNIT_COUNT ; i++)
+ c->transforms.texture[i].validate();
+ }
+
+ // Validate the mvit4 (user-clip planes)
+ if (dirty & transform_state_t::MVIT) {
+ c->transforms.update_mvit();
+ }
+
+ c->transforms.dirty &= ~want;
+}
+
+// ----------------------------------------------------------------------------
+#if 0
+#pragma mark -
+#pragma mark transform_t
+#endif
+
+void transform_t::loadIdentity() {
+ matrix = gIdentityx;
+ flags = 0;
+ ops = OP_IDENTITY;
+ point2 = point2__nop;
+ point3 = point3__nop;
+ point4 = point4__nop;
+}
+
+
+static inline
+int notZero(GLfixed v) {
+ return abs(v) & ~0x3;
+}
+
+static inline
+int notOne(GLfixed v) {
+ return notZero(v - 0x10000);
+}
+
+void transform_t::picker()
+{
+ const GLfixed* const m = matrix.m;
+
+ // XXX: picker needs to be smarter
+ flags = 0;
+ ops = OP_ALL;
+ point2 = point2__generic;
+ point3 = point3__generic;
+ point4 = point4__generic;
+
+ // find out if this is a 2D projection
+ if (!(notZero(m[3]) | notZero(m[7]) | notZero(m[11]) | notOne(m[15]))) {
+ flags |= FLAGS_2D_PROJECTION;
+ }
+}
+
+void mvui_transform_t::picker()
+{
+ flags = 0;
+ ops = OP_ALL;
+ point3 = normal__generic;
+}
+
+void transform_t::dump(const char* what)
+{
+ GLfixed const * const m = matrix.m;
+ LOGD("%s:", what);
+ for (int i=0 ; i<4 ; i++)
+ LOGD("[%08x %08x %08x %08x] [%f %f %f %f]\n",
+ m[I(0,i)], m[I(1,i)], m[I(2,i)], m[I(3,i)],
+ fixedToFloat(m[I(0,i)]),
+ fixedToFloat(m[I(1,i)]),
+ fixedToFloat(m[I(2,i)]),
+ fixedToFloat(m[I(3,i)]));
+}
+
+// ----------------------------------------------------------------------------
+#if 0
+#pragma mark -
+#pragma mark matrixx_t
+#endif
+
+void matrixx_t::load(const matrixf_t& rhs) {
+ GLfixed* xp = m;
+ GLfloat const* fp = rhs.elements();
+ unsigned int i = 16;
+ do {
+ const GLfloat f = *fp++;
+ *xp++ = isZerof(f) ? 0 : gglFloatToFixed(f);
+ } while (--i);
+}
+
+// ----------------------------------------------------------------------------
+#if 0
+#pragma mark -
+#pragma mark matrixf_t
+#endif
+
+void matrixf_t::multiply(matrixf_t& r, const matrixf_t& lhs, const matrixf_t& rhs)
+{
+ GLfloat const* const m = lhs.m;
+ for (int i=0 ; i<4 ; i++) {
+ register const float rhs_i0 = rhs.m[ I(i,0) ];
+ register float ri0 = m[ I(0,0) ] * rhs_i0;
+ register float ri1 = m[ I(0,1) ] * rhs_i0;
+ register float ri2 = m[ I(0,2) ] * rhs_i0;
+ register float ri3 = m[ I(0,3) ] * rhs_i0;
+ for (int j=1 ; j<4 ; j++) {
+ register const float rhs_ij = rhs.m[ I(i,j) ];
+ ri0 += m[ I(j,0) ] * rhs_ij;
+ ri1 += m[ I(j,1) ] * rhs_ij;
+ ri2 += m[ I(j,2) ] * rhs_ij;
+ ri3 += m[ I(j,3) ] * rhs_ij;
+ }
+ r.m[ I(i,0) ] = ri0;
+ r.m[ I(i,1) ] = ri1;
+ r.m[ I(i,2) ] = ri2;
+ r.m[ I(i,3) ] = ri3;
+ }
+}
+
+void matrixf_t::dump(const char* what) {
+ LOGD("%s", what);
+ LOGD("[ %9f %9f %9f %9f ]", m[I(0,0)], m[I(1,0)], m[I(2,0)], m[I(3,0)]);
+ LOGD("[ %9f %9f %9f %9f ]", m[I(0,1)], m[I(1,1)], m[I(2,1)], m[I(3,1)]);
+ LOGD("[ %9f %9f %9f %9f ]", m[I(0,2)], m[I(1,2)], m[I(2,2)], m[I(3,2)]);
+ LOGD("[ %9f %9f %9f %9f ]", m[I(0,3)], m[I(1,3)], m[I(2,3)], m[I(3,3)]);
+}
+
+void matrixf_t::loadIdentity() {
+ memcpy(m, gIdentityf, sizeof(m));
+}
+
+void matrixf_t::set(const GLfixed* rhs) {
+ load(rhs);
+}
+
+void matrixf_t::set(const GLfloat* rhs) {
+ load(rhs);
+}
+
+void matrixf_t::load(const GLfixed* rhs) {
+ GLfloat* fp = m;
+ unsigned int i = 16;
+ do {
+ *fp++ = fixedToFloat(*rhs++);
+ } while (--i);
+}
+
+void matrixf_t::load(const GLfloat* rhs) {
+ memcpy(m, rhs, sizeof(m));
+}
+
+void matrixf_t::load(const matrixf_t& rhs) {
+ operator = (rhs);
+}
+
+void matrixf_t::multiply(const matrixf_t& rhs) {
+ matrixf_t r;
+ multiply(r, *this, rhs);
+ operator = (r);
+}
+
+void matrixf_t::translate(GLfloat x, GLfloat y, GLfloat z) {
+ for (int i=0 ; i<4 ; i++) {
+ m[12+i] += m[i]*x + m[4+i]*y + m[8+i]*z;
+ }
+}
+
+void matrixf_t::scale(GLfloat x, GLfloat y, GLfloat z) {
+ for (int i=0 ; i<4 ; i++) {
+ m[ i] *= x;
+ m[4+i] *= y;
+ m[8+i] *= z;
+ }
+}
+
+void matrixf_t::rotate(GLfloat a, GLfloat x, GLfloat y, GLfloat z)
+{
+ matrixf_t rotation;
+ GLfloat* r = rotation.m;
+ GLfloat c, s;
+ r[3] = 0; r[7] = 0; r[11]= 0;
+ r[12]= 0; r[13]= 0; r[14]= 0; r[15]= 1;
+ a *= GLfloat(M_PI / 180.0f);
+ sincosf(a, &s, &c);
+ if (isOnef(x) && isZerof(y) && isZerof(z)) {
+ r[5] = c; r[10]= c;
+ r[6] = s; r[9] = -s;
+ r[1] = 0; r[2] = 0;
+ r[4] = 0; r[8] = 0;
+ r[0] = 1;
+ } else if (isZerof(x) && isOnef(y) && isZerof(z)) {
+ r[0] = c; r[10]= c;
+ r[8] = s; r[2] = -s;
+ r[1] = 0; r[4] = 0;
+ r[6] = 0; r[9] = 0;
+ r[5] = 1;
+ } else if (isZerof(x) && isZerof(y) && isOnef(z)) {
+ r[0] = c; r[5] = c;
+ r[1] = s; r[4] = -s;
+ r[2] = 0; r[6] = 0;
+ r[8] = 0; r[9] = 0;
+ r[10]= 1;
+ } else {
+ const GLfloat len = sqrtf(x*x + y*y + z*z);
+ if (!isOnef(len)) {
+ const GLfloat recipLen = reciprocalf(len);
+ x *= recipLen;
+ y *= recipLen;
+ z *= recipLen;
+ }
+ const GLfloat nc = 1.0f - c;
+ const GLfloat xy = x * y;
+ const GLfloat yz = y * z;
+ const GLfloat zx = z * x;
+ const GLfloat xs = x * s;
+ const GLfloat ys = y * s;
+ const GLfloat zs = z * s;
+ r[ 0] = x*x*nc + c; r[ 4] = xy*nc - zs; r[ 8] = zx*nc + ys;
+ r[ 1] = xy*nc + zs; r[ 5] = y*y*nc + c; r[ 9] = yz*nc - xs;
+ r[ 2] = zx*nc - ys; r[ 6] = yz*nc + xs; r[10] = z*z*nc + c;
+ }
+ multiply(rotation);
+}
+
+// ----------------------------------------------------------------------------
+#if 0
+#pragma mark -
+#pragma mark matrix_stack_t
+#endif
+
+void matrix_stack_t::init(int depth) {
+ stack = new matrixf_t[depth];
+ ops = new uint8_t[depth];
+ maxDepth = depth;
+ depth = 0;
+ dirty = 0;
+ loadIdentity();
+}
+
+void matrix_stack_t::uninit() {
+ delete [] stack;
+ delete [] ops;
+}
+
+void matrix_stack_t::loadIdentity() {
+ transform.loadIdentity();
+ stack[depth].loadIdentity();
+ ops[depth] = OP_IDENTITY;
+}
+
+void matrix_stack_t::load(const GLfixed* rhs)
+{
+ memcpy(transform.matrix.m, rhs, sizeof(transform.matrix.m));
+ stack[depth].load(rhs);
+ ops[depth] = OP_ALL; // TODO: we should look at the matrix
+}
+
+void matrix_stack_t::load(const GLfloat* rhs)
+{
+ stack[depth].load(rhs);
+ ops[depth] = OP_ALL; // TODO: we should look at the matrix
+}
+
+void matrix_stack_t::multiply(const matrixf_t& rhs)
+{
+ stack[depth].multiply(rhs);
+ ops[depth] = OP_ALL; // TODO: we should look at the matrix
+}
+
+void matrix_stack_t::translate(GLfloat x, GLfloat y, GLfloat z)
+{
+ stack[depth].translate(x,y,z);
+ ops[depth] |= OP_TRANSLATE;
+}
+
+void matrix_stack_t::scale(GLfloat x, GLfloat y, GLfloat z)
+{
+ stack[depth].scale(x,y,z);
+ if (x==y && y==z) {
+ ops[depth] |= OP_UNIFORM_SCALE;
+ } else {
+ ops[depth] |= OP_SCALE;
+ }
+}
+
+void matrix_stack_t::rotate(GLfloat a, GLfloat x, GLfloat y, GLfloat z)
+{
+ stack[depth].rotate(a,x,y,z);
+ ops[depth] |= OP_ROTATE;
+}
+
+void matrix_stack_t::validate()
+{
+ if (dirty & DO_FLOAT_TO_FIXED) {
+ transform.matrix.load(top());
+ }
+ if (dirty & DO_PICKER) {
+ transform.picker();
+ }
+ dirty = 0;
+}
+
+GLint matrix_stack_t::push()
+{
+ if (depth >= (maxDepth-1)) {
+ return GL_STACK_OVERFLOW;
+ }
+ stack[depth+1] = stack[depth];
+ ops[depth+1] = ops[depth];
+ depth++;
+ return 0;
+}
+
+GLint matrix_stack_t::pop()
+{
+ if (depth == 0) {
+ return GL_STACK_UNDERFLOW;
+ }
+ depth--;
+ return 0;
+}
+
+// ----------------------------------------------------------------------------
+#if 0
+#pragma mark -
+#pragma mark vp_transform_t
+#endif
+
+void vp_transform_t::loadIdentity() {
+ transform.loadIdentity();
+ matrix.loadIdentity();
+}
+
+// ----------------------------------------------------------------------------
+#if 0
+#pragma mark -
+#pragma mark transform_state_t
+#endif
+
+void transform_state_t::invalidate()
+{
+ switch (matrixMode) {
+ case GL_MODELVIEW: dirty |= MODELVIEW | MVP | MVUI | MVIT; break;
+ case GL_PROJECTION: dirty |= PROJECTION | MVP; break;
+ case GL_TEXTURE: dirty |= TEXTURE | MVP; break;
+ }
+ current->dirty = matrix_stack_t::DO_PICKER |
+ matrix_stack_t::DO_FLOAT_TO_FIXED;
+}
+
+void transform_state_t::update_mvp()
+{
+ matrixf_t temp_mvp;
+ matrixf_t::multiply(temp_mvp, projection.top(), modelview.top());
+ mvp4.matrix.load(temp_mvp);
+ mvp4.picker();
+
+ if (mvp4.flags & transform_t::FLAGS_2D_PROJECTION) {
+ // the mvp matrix doesn't transform W, in this case we can
+ // premultiply it with the viewport transformation. In addition to
+ // being more efficient, this is also much more accurate and in fact
+ // is needed for 2D drawing with a resulting 1:1 mapping.
+ matrixf_t mvpv;
+ matrixf_t::multiply(mvpv, vpt.matrix, temp_mvp);
+ mvp.matrix.load(mvpv);
+ mvp.picker();
+ } else {
+ mvp = mvp4;
+ }
+}
+
+static inline
+GLfloat det22(GLfloat a, GLfloat b, GLfloat c, GLfloat d) {
+ return a*d - b*c;
+}
+
+static inline
+GLfloat ndet22(GLfloat a, GLfloat b, GLfloat c, GLfloat d) {
+ return b*c - a*d;
+}
+
+static __attribute__((noinline))
+void invert(GLfloat* inverse, const GLfloat* src)
+{
+ double t;
+ int i, j, k, swap;
+ GLfloat tmp[4][4];
+
+ memcpy(inverse, gIdentityf, sizeof(gIdentityf));
+ memcpy(tmp, src, sizeof(GLfloat)*16);
+
+ for (i = 0; i < 4; i++) {
+ // look for largest element in column
+ swap = i;
+ for (j = i + 1; j < 4; j++) {
+ if (fabs(tmp[j][i]) > fabs(tmp[i][i])) {
+ swap = j;
+ }
+ }
+
+ if (swap != i) {
+ /* swap rows. */
+ for (k = 0; k < 4; k++) {
+ t = tmp[i][k];
+ tmp[i][k] = tmp[swap][k];
+ tmp[swap][k] = t;
+
+ t = inverse[i*4+k];
+ inverse[i*4+k] = inverse[swap*4+k];
+ inverse[swap*4+k] = t;
+ }
+ }
+
+ t = 1.0f / tmp[i][i];
+ for (k = 0; k < 4; k++) {
+ tmp[i][k] *= t;
+ inverse[i*4+k] *= t;
+ }
+ for (j = 0; j < 4; j++) {
+ if (j != i) {
+ t = tmp[j][i];
+ for (k = 0; k < 4; k++) {
+ tmp[j][k] -= tmp[i][k]*t;
+ inverse[j*4+k] -= inverse[i*4+k]*t;
+ }
+ }
+ }
+ }
+}
+
+void transform_state_t::update_mvit()
+{
+ GLfloat r[16];
+ const GLfloat* const mv = modelview.top().elements();
+ invert(r, mv);
+ // convert to fixed-point and transpose
+ GLfixed* const x = mvit4.matrix.m;
+ for (int i=0 ; i<4 ; i++)
+ for (int j=0 ; j<4 ; j++)
+ x[I(i,j)] = gglFloatToFixed(r[I(j,i)]);
+ mvit4.picker();
+}
+
+void transform_state_t::update_mvui()
+{
+ const GLfloat* const mv = modelview.top().elements();
+
+ /*
+ When transforming normals, we can use the upper 3x3 matrix, see:
+ http://www.opengl.org/documentation/specs/version1.1/glspec1.1/node26.html
+ */
+
+ // Also note that:
+ // l(obj) = tr(M).l(eye) for infinite light
+ // l(obj) = inv(M).l(eye) for local light
+
+ const uint32_t ops = modelview.top_ops() & ~OP_TRANSLATE;
+ if (ggl_likely((!(ops & ~OP_ROTATE)) ||
+ (rescaleNormals && modelview.isRigidBody()))) {
+ // if the modelview matrix is a rigid body transformation
+ // (translation, rotation, uniform scaling), then we can bypass
+ // the inverse by transposing the matrix.
+ GLfloat rescale = 1.0f;
+ if (rescaleNormals == GL_RESCALE_NORMAL) {
+ if (!(ops & ~OP_UNIFORM_SCALE)) {
+ rescale = reciprocalf(mv[I(0,0)]);
+ } else {
+ rescale = rsqrtf(
+ sqrf(mv[I(2,0)]) + sqrf(mv[I(2,1)]) + sqrf(mv[I(2,2)]));
+ }
+ }
+ GLfixed* const x = mvui.matrix.m;
+ for (int i=0 ; i<3 ; i++) {
+ x[I(i,0)] = gglFloatToFixed(mv[I(0,i)] * rescale);
+ x[I(i,1)] = gglFloatToFixed(mv[I(1,i)] * rescale);
+ x[I(i,2)] = gglFloatToFixed(mv[I(2,i)] * rescale);
+ }
+ mvui.picker();
+ return;
+ }
+
+ GLfloat r[3][3];
+ r[0][0] = det22(mv[I(1,1)], mv[I(2,1)], mv[I(1,2)], mv[I(2,2)]);
+ r[0][1] =ndet22(mv[I(0,1)], mv[I(2,1)], mv[I(0,2)], mv[I(2,2)]);
+ r[0][2] = det22(mv[I(0,1)], mv[I(1,1)], mv[I(0,2)], mv[I(1,2)]);
+ r[1][0] =ndet22(mv[I(1,0)], mv[I(2,0)], mv[I(1,2)], mv[I(2,2)]);
+ r[1][1] = det22(mv[I(0,0)], mv[I(2,0)], mv[I(0,2)], mv[I(2,2)]);
+ r[1][2] =ndet22(mv[I(0,0)], mv[I(1,0)], mv[I(0,2)], mv[I(1,2)]);
+ r[2][0] = det22(mv[I(1,0)], mv[I(2,0)], mv[I(1,1)], mv[I(2,1)]);
+ r[2][1] =ndet22(mv[I(0,0)], mv[I(2,0)], mv[I(0,1)], mv[I(2,1)]);
+ r[2][2] = det22(mv[I(0,0)], mv[I(1,0)], mv[I(0,1)], mv[I(1,1)]);
+
+ GLfloat rdet;
+ if (rescaleNormals == GL_RESCALE_NORMAL) {
+ rdet = rsqrtf(sqrf(r[0][2]) + sqrf(r[1][2]) + sqrf(r[2][2]));
+ } else {
+ rdet = reciprocalf(
+ r[0][0]*mv[I(0,0)] + r[0][1]*mv[I(1,0)] + r[0][2]*mv[I(2,0)]);
+ }
+
+ GLfixed* const x = mvui.matrix.m;
+ for (int i=0 ; i<3 ; i++) {
+ x[I(i,0)] = gglFloatToFixed(r[i][0] * rdet);
+ x[I(i,1)] = gglFloatToFixed(r[i][1] * rdet);
+ x[I(i,2)] = gglFloatToFixed(r[i][2] * rdet);
+ }
+ mvui.picker();
+}
+
+
+// ----------------------------------------------------------------------------
+// transformation and matrices API
+// ----------------------------------------------------------------------------
+#if 0
+#pragma mark -
+#pragma mark transformation and matrices API
+#endif
+
+int ogles_surfaceport(ogles_context_t* c, GLint x, GLint y)
+{
+ c->viewport.surfaceport.x = x;
+ c->viewport.surfaceport.y = y;
+
+ ogles_viewport(c,
+ c->viewport.x,
+ c->viewport.y,
+ c->viewport.w,
+ c->viewport.h);
+
+ ogles_scissor(c,
+ c->viewport.scissor.x,
+ c->viewport.scissor.y,
+ c->viewport.scissor.w,
+ c->viewport.scissor.h);
+
+ return 0;
+}
+
+void ogles_scissor(ogles_context_t* c,
+ GLint x, GLint y, GLsizei w, GLsizei h)
+{
+ if ((w|h) < 0) {
+ ogles_error(c, GL_INVALID_VALUE);
+ return;
+ }
+ c->viewport.scissor.x = x;
+ c->viewport.scissor.y = y;
+ c->viewport.scissor.w = w;
+ c->viewport.scissor.h = h;
+
+ x += c->viewport.surfaceport.x;
+ y += c->viewport.surfaceport.y;
+
+ y = c->rasterizer.state.buffers.color.height - (y + h);
+ c->rasterizer.procs.scissor(c, x, y, w, h);
+}
+
+void ogles_viewport(ogles_context_t* c,
+ GLint x, GLint y, GLsizei w, GLsizei h)
+{
+ if ((w|h)<0) {
+ ogles_error(c, GL_INVALID_VALUE);
+ return;
+ }
+
+ c->viewport.x = x;
+ c->viewport.y = y;
+ c->viewport.w = w;
+ c->viewport.h = h;
+
+ x += c->viewport.surfaceport.x;
+ y += c->viewport.surfaceport.y;
+
+ GLint H = c->rasterizer.state.buffers.color.height;
+ GLfloat sx = div2f(w);
+ GLfloat ox = sx + x;
+ GLfloat sy = div2f(h);
+ GLfloat oy = sy - y + (H - h);
+
+ GLfloat near = c->transforms.vpt.zNear;
+ GLfloat far = c->transforms.vpt.zFar;
+ GLfloat A = div2f(far - near);
+ GLfloat B = div2f(far + near);
+
+ // compute viewport matrix
+ GLfloat* const f = c->transforms.vpt.matrix.editElements();
+ f[0] = sx; f[4] = 0; f[ 8] = 0; f[12] = ox;
+ f[1] = 0; f[5] =-sy; f[ 9] = 0; f[13] = oy;
+ f[2] = 0; f[6] = 0; f[10] = A; f[14] = B;
+ f[3] = 0; f[7] = 0; f[11] = 0; f[15] = 1;
+ c->transforms.dirty |= transform_state_t::VIEWPORT;
+}
+
+// ----------------------------------------------------------------------------
+#if 0
+#pragma mark -
+#pragma mark matrix * vertex
+#endif
+
+void point2__generic(transform_t const* mx, vec4_t* lhs, vec4_t const* rhs) {
+ const GLfixed* const m = mx->matrix.m;
+ const GLfixed rx = rhs->x;
+ const GLfixed ry = rhs->y;
+ lhs->x = mla2a(rx, m[ 0], ry, m[ 4], m[12]);
+ lhs->y = mla2a(rx, m[ 1], ry, m[ 5], m[13]);
+ lhs->z = mla2a(rx, m[ 2], ry, m[ 6], m[14]);
+ lhs->w = mla2a(rx, m[ 3], ry, m[ 7], m[15]);
+}
+
+void point3__generic(transform_t const* mx, vec4_t* lhs, vec4_t const* rhs) {
+ const GLfixed* const m = mx->matrix.m;
+ const GLfixed rx = rhs->x;
+ const GLfixed ry = rhs->y;
+ const GLfixed rz = rhs->z;
+ lhs->x = mla3a(rx, m[ 0], ry, m[ 4], rz, m[ 8], m[12]);
+ lhs->y = mla3a(rx, m[ 1], ry, m[ 5], rz, m[ 9], m[13]);
+ lhs->z = mla3a(rx, m[ 2], ry, m[ 6], rz, m[10], m[14]);
+ lhs->w = mla3a(rx, m[ 3], ry, m[ 7], rz, m[11], m[15]);
+}
+
+void point4__generic(transform_t const* mx, vec4_t* lhs, vec4_t const* rhs) {
+ const GLfixed* const m = mx->matrix.m;
+ const GLfixed rx = rhs->x;
+ const GLfixed ry = rhs->y;
+ const GLfixed rz = rhs->z;
+ const GLfixed rw = rhs->w;
+ lhs->x = mla4(rx, m[ 0], ry, m[ 4], rz, m[ 8], rw, m[12]);
+ lhs->y = mla4(rx, m[ 1], ry, m[ 5], rz, m[ 9], rw, m[13]);
+ lhs->z = mla4(rx, m[ 2], ry, m[ 6], rz, m[10], rw, m[14]);
+ lhs->w = mla4(rx, m[ 3], ry, m[ 7], rz, m[11], rw, m[15]);
+}
+
+void normal__generic(transform_t const* mx, vec4_t* lhs, vec4_t const* rhs) {
+ const GLfixed* const m = mx->matrix.m;
+ const GLfixed rx = rhs->x;
+ const GLfixed ry = rhs->y;
+ const GLfixed rz = rhs->z;
+ lhs->x = mla3(rx, m[ 0], ry, m[ 4], rz, m[ 8]);
+ lhs->y = mla3(rx, m[ 1], ry, m[ 5], rz, m[ 9]);
+ lhs->z = mla3(rx, m[ 2], ry, m[ 6], rz, m[10]);
+}
+
+
+void point2__nop(transform_t const*, vec4_t* lhs, vec4_t const* rhs) {
+ lhs->z = 0;
+ lhs->w = 0x10000;
+ if (lhs != rhs) {
+ lhs->x = rhs->x;
+ lhs->y = rhs->y;
+ }
+}
+
+void point3__nop(transform_t const*, vec4_t* lhs, vec4_t const* rhs) {
+ lhs->w = 0x10000;
+ if (lhs != rhs) {
+ lhs->x = rhs->x;
+ lhs->y = rhs->y;
+ lhs->z = rhs->z;
+ }
+}
+
+void point4__nop(transform_t const*, vec4_t* lhs, vec4_t const* rhs) {
+ if (lhs != rhs)
+ *lhs = *rhs;
+}
+
+
+static void frustumf(
+ GLfloat left, GLfloat right,
+ GLfloat bottom, GLfloat top,
+ GLfloat zNear, GLfloat zFar,
+ ogles_context_t* c)
+ {
+ if (cmpf(left,right) ||
+ cmpf(top, bottom) ||
+ cmpf(zNear, zFar) ||
+ isZeroOrNegativef(zNear) ||
+ isZeroOrNegativef(zFar))
+ {
+ ogles_error(c, GL_INVALID_VALUE);
+ return;
+ }
+ const GLfloat r_width = reciprocalf(right - left);
+ const GLfloat r_height = reciprocalf(top - bottom);
+ const GLfloat r_depth = reciprocalf(zNear - zFar);
+ const GLfloat x = mul2f(zNear * r_width);
+ const GLfloat y = mul2f(zNear * r_height);
+ const GLfloat A = mul2f((right + left) * r_width);
+ const GLfloat B = (top + bottom) * r_height;
+ const GLfloat C = (zFar + zNear) * r_depth;
+ const GLfloat D = mul2f(zFar * zNear * r_depth);
+ GLfloat f[16];
+ f[ 0] = x;
+ f[ 5] = y;
+ f[ 8] = A;
+ f[ 9] = B;
+ f[10] = C;
+ f[14] = D;
+ f[11] = -1.0f;
+ f[ 1] = f[ 2] = f[ 3] =
+ f[ 4] = f[ 6] = f[ 7] =
+ f[12] = f[13] = f[15] = 0.0f;
+
+ matrixf_t rhs;
+ rhs.set(f);
+ c->transforms.current->multiply(rhs);
+ c->transforms.invalidate();
+}
+
+static void orthof(
+ GLfloat left, GLfloat right,
+ GLfloat bottom, GLfloat top,
+ GLfloat zNear, GLfloat zFar,
+ ogles_context_t* c)
+{
+ if (cmpf(left,right) ||
+ cmpf(top, bottom) ||
+ cmpf(zNear, zFar))
+ {
+ ogles_error(c, GL_INVALID_VALUE);
+ return;
+ }
+ const GLfloat r_width = reciprocalf(right - left);
+ const GLfloat r_height = reciprocalf(top - bottom);
+ const GLfloat r_depth = reciprocalf(zFar - zNear);
+ const GLfloat x = mul2f(r_width);
+ const GLfloat y = mul2f(r_height);
+ const GLfloat z = -mul2f(r_depth);
+ const GLfloat tx = -(right + left) * r_width;
+ const GLfloat ty = -(top + bottom) * r_height;
+ const GLfloat tz = -(zFar + zNear) * r_depth;
+ GLfloat f[16];
+ f[ 0] = x;
+ f[ 5] = y;
+ f[10] = z;
+ f[12] = tx;
+ f[13] = ty;
+ f[14] = tz;
+ f[15] = 1.0f;
+ f[ 1] = f[ 2] = f[ 3] =
+ f[ 4] = f[ 6] = f[ 7] =
+ f[ 8] = f[ 9] = f[11] = 0.0f;
+ matrixf_t rhs;
+ rhs.set(f);
+ c->transforms.current->multiply(rhs);
+ c->transforms.invalidate();
+}
+
+static void depthRangef(GLclampf zNear, GLclampf zFar, ogles_context_t* c)
+{
+ zNear = clampToZerof(zNear > 1 ? 1 : zNear);
+ zFar = clampToZerof(zFar > 1 ? 1 : zFar);
+ GLfloat* const f = c->transforms.vpt.matrix.editElements();
+ f[10] = div2f(zFar - zNear);
+ f[14] = div2f(zFar + zNear);
+ c->transforms.dirty |= transform_state_t::VIEWPORT;
+ c->transforms.vpt.zNear = zNear;
+ c->transforms.vpt.zFar = zFar;
+}
+
+
+// ----------------------------------------------------------------------------
+}; // namespace android
+
+using namespace android;
+
+void glMatrixMode(GLenum mode)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ matrix_stack_t* stack = 0;
+ switch (mode) {
+ case GL_MODELVIEW:
+ stack = &c->transforms.modelview;
+ break;
+ case GL_PROJECTION:
+ stack = &c->transforms.projection;
+ break;
+ case GL_TEXTURE:
+ stack = &c->transforms.texture[c->textures.active];
+ break;
+ default:
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ c->transforms.matrixMode = mode;
+ c->transforms.current = stack;
+}
+
+void glLoadIdentity()
+{
+ ogles_context_t* c = ogles_context_t::get();
+ c->transforms.current->loadIdentity(); // also loads the GLfixed transform
+ c->transforms.invalidate();
+ c->transforms.current->dirty = 0;
+}
+
+void glLoadMatrixf(const GLfloat* m)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ c->transforms.current->load(m);
+ c->transforms.invalidate();
+}
+
+void glLoadMatrixx(const GLfixed* m)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ c->transforms.current->load(m); // also loads the GLfixed transform
+ c->transforms.invalidate();
+ c->transforms.current->dirty &= ~matrix_stack_t::DO_FLOAT_TO_FIXED;
+}
+
+void glMultMatrixf(const GLfloat* m)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ matrixf_t rhs;
+ rhs.set(m);
+ c->transforms.current->multiply(rhs);
+ c->transforms.invalidate();
+}
+
+void glMultMatrixx(const GLfixed* m)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ matrixf_t rhs;
+ rhs.set(m);
+ c->transforms.current->multiply(rhs);
+ c->transforms.invalidate();
+}
+
+void glPopMatrix()
+{
+ ogles_context_t* c = ogles_context_t::get();
+ GLint err = c->transforms.current->pop();
+ if (ggl_unlikely(err)) {
+ ogles_error(c, err);
+ return;
+ }
+ c->transforms.invalidate();
+}
+
+void glPushMatrix()
+{
+ ogles_context_t* c = ogles_context_t::get();
+ GLint err = c->transforms.current->push();
+ if (ggl_unlikely(err)) {
+ ogles_error(c, err);
+ return;
+ }
+ c->transforms.invalidate();
+}
+
+void glFrustumf(
+ GLfloat left, GLfloat right,
+ GLfloat bottom, GLfloat top,
+ GLfloat zNear, GLfloat zFar)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ frustumf(left, right, bottom, top, zNear, zFar, c);
+}
+
+void glFrustumx(
+ GLfixed left, GLfixed right,
+ GLfixed bottom, GLfixed top,
+ GLfixed zNear, GLfixed zFar)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ frustumf( fixedToFloat(left), fixedToFloat(right),
+ fixedToFloat(bottom), fixedToFloat(top),
+ fixedToFloat(zNear), fixedToFloat(zFar),
+ c);
+}
+
+void glOrthof(
+ GLfloat left, GLfloat right,
+ GLfloat bottom, GLfloat top,
+ GLfloat zNear, GLfloat zFar)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ orthof(left, right, bottom, top, zNear, zFar, c);
+}
+
+void glOrthox(
+ GLfixed left, GLfixed right,
+ GLfixed bottom, GLfixed top,
+ GLfixed zNear, GLfixed zFar)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ orthof( fixedToFloat(left), fixedToFloat(right),
+ fixedToFloat(bottom), fixedToFloat(top),
+ fixedToFloat(zNear), fixedToFloat(zFar),
+ c);
+}
+
+void glRotatef(GLfloat a, GLfloat x, GLfloat y, GLfloat z)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ c->transforms.current->rotate(a, x, y, z);
+ c->transforms.invalidate();
+}
+
+void glRotatex(GLfixed a, GLfixed x, GLfixed y, GLfixed z)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ c->transforms.current->rotate(
+ fixedToFloat(a), fixedToFloat(x),
+ fixedToFloat(y), fixedToFloat(z));
+ c->transforms.invalidate();
+}
+
+void glScalef(GLfloat x, GLfloat y, GLfloat z)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ c->transforms.current->scale(x, y, z);
+ c->transforms.invalidate();
+}
+
+void glScalex(GLfixed x, GLfixed y, GLfixed z)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ c->transforms.current->scale(
+ fixedToFloat(x), fixedToFloat(y), fixedToFloat(z));
+ c->transforms.invalidate();
+}
+
+void glTranslatef(GLfloat x, GLfloat y, GLfloat z)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ c->transforms.current->translate(x, y, z);
+ c->transforms.invalidate();
+}
+
+void glTranslatex(GLfixed x, GLfixed y, GLfixed z)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ c->transforms.current->translate(
+ fixedToFloat(x), fixedToFloat(y), fixedToFloat(z));
+ c->transforms.invalidate();
+}
+
+void glScissor(GLint x, GLint y, GLsizei w, GLsizei h)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ ogles_scissor(c, x, y, w, h);
+}
+
+void glViewport(GLint x, GLint y, GLsizei w, GLsizei h)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ ogles_viewport(c, x, y, w, h);
+}
+
+void glDepthRangef(GLclampf zNear, GLclampf zFar)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ depthRangef(zNear, zFar, c);
+}
+
+void glDepthRangex(GLclampx zNear, GLclampx zFar)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ depthRangef(fixedToFloat(zNear), fixedToFloat(zFar), c);
+}
+
+void glPolygonOffsetx(GLfixed factor, GLfixed units)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ c->polygonOffset.factor = factor;
+ c->polygonOffset.units = units;
+}
+
+void glPolygonOffset(GLfloat factor, GLfloat units)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ c->polygonOffset.factor = gglFloatToFixed(factor);
+ c->polygonOffset.units = gglFloatToFixed(units);
+}
+
+GLbitfield glQueryMatrixxOES(GLfixed* m, GLint* e)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ GLbitfield status = 0;
+ GLfloat const* f = c->transforms.current->top().elements();
+ for (int i=0 ; i<16 ; i++) {
+ if (isnan(f[i]) || isinf(f[i])) {
+ status |= 1<<i;
+ continue;
+ }
+ e[i] = exponent(f[i]) - 7;
+ m[i] = mantissa(f[i]);
+ }
+ return status;
+}
diff --git a/opengl/libagl/matrix.h b/opengl/libagl/matrix.h
new file mode 100644
index 0000000..c9a38a9
--- /dev/null
+++ b/opengl/libagl/matrix.h
@@ -0,0 +1,355 @@
+/* libs/opengles/matrix.h
+**
+** Copyright 2006, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+** http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+#ifndef ANDROID_OPENGLES_MATRIX_H
+#define ANDROID_OPENGLES_MATRIX_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include <sys/types.h>
+#include <utils/Log.h>
+
+#include <private/pixelflinger/ggl_context.h>
+
+#include <GLES/gl.h>
+
+namespace android {
+
+const int OGLES_MODELVIEW_STACK_DEPTH = 16;
+const int OGLES_PROJECTION_STACK_DEPTH = 2;
+const int OGLES_TEXTURE_STACK_DEPTH = 2;
+
+void ogles_init_matrix(ogles_context_t*);
+void ogles_uninit_matrix(ogles_context_t*);
+void ogles_invalidate_perspective(ogles_context_t* c);
+void ogles_validate_transform_impl(ogles_context_t* c, uint32_t want);
+
+int ogles_surfaceport(ogles_context_t* c, GLint x, GLint y);
+
+void ogles_scissor(ogles_context_t* c,
+ GLint x, GLint y, GLsizei w, GLsizei h);
+
+void ogles_viewport(ogles_context_t* c,
+ GLint x, GLint y, GLsizei w, GLsizei h);
+
+inline void ogles_validate_transform(
+ ogles_context_t* c, uint32_t want)
+{
+ if (c->transforms.dirty & want)
+ ogles_validate_transform_impl(c, want);
+}
+
+// ----------------------------------------------------------------------------
+
+inline
+GLfixed vsquare3(GLfixed a, GLfixed b, GLfixed c)
+{
+#if defined(__arm__) && !defined(__thumb__)
+
+ GLfixed r;
+ int32_t t;
+ asm(
+ "smull %0, %1, %2, %2 \n"
+ "smlal %0, %1, %3, %3 \n"
+ "smlal %0, %1, %4, %4 \n"
+ "movs %0, %0, lsr #16 \n"
+ "adc %0, %0, %1, lsl #16 \n"
+ : "=&r"(r), "=&r"(t)
+ : "%r"(a), "r"(b), "r"(c)
+ : "cc"
+ );
+ return r;
+
+#else
+
+ return (( int64_t(a)*a +
+ int64_t(b)*b +
+ int64_t(c)*c + 0x8000)>>16);
+
+#endif
+}
+
+static inline GLfixed mla2a( GLfixed a0, GLfixed b0,
+ GLfixed a1, GLfixed b1,
+ GLfixed c)
+{
+#if defined(__arm__) && !defined(__thumb__)
+
+ GLfixed r;
+ int32_t t;
+ asm(
+ "smull %0, %1, %2, %3 \n"
+ "smlal %0, %1, %4, %5 \n"
+ "add %0, %6, %0, lsr #16 \n"
+ "add %0, %0, %1, lsl #16 \n"
+ : "=&r"(r), "=&r"(t)
+ : "%r"(a0), "r"(b0),
+ "%r"(a1), "r"(b1),
+ "r"(c)
+ :
+ );
+ return r;
+
+#else
+
+ return (( int64_t(a0)*b0 +
+ int64_t(a1)*b1)>>16) + c;
+
+#endif
+}
+
+static inline GLfixed mla3a( GLfixed a0, GLfixed b0,
+ GLfixed a1, GLfixed b1,
+ GLfixed a2, GLfixed b2,
+ GLfixed c)
+{
+#if defined(__arm__) && !defined(__thumb__)
+
+ GLfixed r;
+ int32_t t;
+ asm(
+ "smull %0, %1, %2, %3 \n"
+ "smlal %0, %1, %4, %5 \n"
+ "smlal %0, %1, %6, %7 \n"
+ "add %0, %8, %0, lsr #16 \n"
+ "add %0, %0, %1, lsl #16 \n"
+ : "=&r"(r), "=&r"(t)
+ : "%r"(a0), "r"(b0),
+ "%r"(a1), "r"(b1),
+ "%r"(a2), "r"(b2),
+ "r"(c)
+ :
+ );
+ return r;
+
+#else
+
+ return (( int64_t(a0)*b0 +
+ int64_t(a1)*b1 +
+ int64_t(a2)*b2)>>16) + c;
+
+#endif
+}
+
+// b0, b1, b2 are signed 16-bit quanities
+// that have been shifted right by 'shift' bits relative to normal
+// S16.16 fixed point
+static inline GLfixed mla3a16( GLfixed a0, int32_t b1b0,
+ GLfixed a1,
+ GLfixed a2, int32_t b2,
+ GLint shift,
+ GLfixed c)
+{
+#if defined(__arm__) && !defined(__thumb__)
+
+ GLfixed r;
+ asm(
+ "smulwb %0, %1, %2 \n"
+ "smlawt %0, %3, %2, %0 \n"
+ "smlawb %0, %4, %5, %0 \n"
+ "add %0, %7, %0, lsl %6 \n"
+ : "=&r"(r)
+ : "r"(a0), "r"(b1b0),
+ "r"(a1),
+ "r"(a2), "r"(b2),
+ "r"(shift),
+ "r"(c)
+ :
+ );
+ return r;
+
+#else
+
+ int32_t accum;
+ int16_t b0 = b1b0 & 0xffff;
+ int16_t b1 = (b1b0 >> 16) & 0xffff;
+ accum = int64_t(a0)*int16_t(b0) >> 16;
+ accum += int64_t(a1)*int16_t(b1) >> 16;
+ accum += int64_t(a2)*int16_t(b2) >> 16;
+ accum = (accum << shift) + c;
+ return accum;
+
+#endif
+}
+
+
+static inline GLfixed mla3a16_btb( GLfixed a0,
+ GLfixed a1,
+ GLfixed a2,
+ int32_t b1b0, int32_t xxb2,
+ GLint shift,
+ GLfixed c)
+{
+#if defined(__arm__) && !defined(__thumb__)
+
+ GLfixed r;
+ asm(
+ "smulwb %0, %1, %4 \n"
+ "smlawt %0, %2, %4, %0 \n"
+ "smlawb %0, %3, %5, %0 \n"
+ "add %0, %7, %0, lsl %6 \n"
+ : "=&r"(r)
+ : "r"(a0),
+ "r"(a1),
+ "r"(a2),
+ "r"(b1b0), "r"(xxb2),
+ "r"(shift),
+ "r"(c)
+ :
+ );
+ return r;
+
+#else
+
+ int32_t accum;
+ int16_t b0 = b1b0 & 0xffff;
+ int16_t b1 = (b1b0 >> 16) & 0xffff;
+ int16_t b2 = xxb2 & 0xffff;
+ accum = int64_t(a0)*int16_t(b0) >> 16;
+ accum += int64_t(a1)*int16_t(b1) >> 16;
+ accum += int64_t(a2)*int16_t(b2) >> 16;
+ accum = (accum << shift) + c;
+ return accum;
+
+#endif
+}
+
+static inline GLfixed mla3a16_btt( GLfixed a0,
+ GLfixed a1,
+ GLfixed a2,
+ int32_t b1b0, int32_t b2xx,
+ GLint shift,
+ GLfixed c)
+{
+#if defined(__arm__) && !defined(__thumb__)
+
+ GLfixed r;
+ asm(
+ "smulwb %0, %1, %4 \n"
+ "smlawt %0, %2, %4, %0 \n"
+ "smlawt %0, %3, %5, %0 \n"
+ "add %0, %7, %0, lsl %6 \n"
+ : "=&r"(r)
+ : "r"(a0),
+ "r"(a1),
+ "r"(a2),
+ "r"(b1b0), "r"(b2xx),
+ "r"(shift),
+ "r"(c)
+ :
+ );
+ return r;
+
+#else
+
+ int32_t accum;
+ int16_t b0 = b1b0 & 0xffff;
+ int16_t b1 = (b1b0 >> 16) & 0xffff;
+ int16_t b2 = (b2xx >> 16) & 0xffff;
+ accum = int64_t(a0)*int16_t(b0) >> 16;
+ accum += int64_t(a1)*int16_t(b1) >> 16;
+ accum += int64_t(a2)*int16_t(b2) >> 16;
+ accum = (accum << shift) + c;
+ return accum;
+
+#endif
+}
+
+static inline GLfixed mla3( GLfixed a0, GLfixed b0,
+ GLfixed a1, GLfixed b1,
+ GLfixed a2, GLfixed b2)
+{
+#if defined(__arm__) && !defined(__thumb__)
+
+ GLfixed r;
+ int32_t t;
+ asm(
+ "smull %0, %1, %2, %3 \n"
+ "smlal %0, %1, %4, %5 \n"
+ "smlal %0, %1, %6, %7 \n"
+ "movs %0, %0, lsr #16 \n"
+ "adc %0, %0, %1, lsl #16 \n"
+ : "=&r"(r), "=&r"(t)
+ : "%r"(a0), "r"(b0),
+ "%r"(a1), "r"(b1),
+ "%r"(a2), "r"(b2)
+ : "cc"
+ );
+ return r;
+
+#else
+
+ return (( int64_t(a0)*b0 +
+ int64_t(a1)*b1 +
+ int64_t(a2)*b2 + 0x8000)>>16);
+
+#endif
+}
+
+static inline GLfixed mla4( GLfixed a0, GLfixed b0,
+ GLfixed a1, GLfixed b1,
+ GLfixed a2, GLfixed b2,
+ GLfixed a3, GLfixed b3)
+{
+#if defined(__arm__) && !defined(__thumb__)
+
+ GLfixed r;
+ int32_t t;
+ asm(
+ "smull %0, %1, %2, %3 \n"
+ "smlal %0, %1, %4, %5 \n"
+ "smlal %0, %1, %6, %7 \n"
+ "smlal %0, %1, %8, %9 \n"
+ "movs %0, %0, lsr #16 \n"
+ "adc %0, %0, %1, lsl #16 \n"
+ : "=&r"(r), "=&r"(t)
+ : "%r"(a0), "r"(b0),
+ "%r"(a1), "r"(b1),
+ "%r"(a2), "r"(b2),
+ "%r"(a3), "r"(b3)
+ : "cc"
+ );
+ return r;
+
+#else
+
+ return (( int64_t(a0)*b0 +
+ int64_t(a1)*b1 +
+ int64_t(a2)*b2 +
+ int64_t(a3)*b3 + 0x8000)>>16);
+
+#endif
+}
+
+inline
+GLfixed dot4(const GLfixed* a, const GLfixed* b)
+{
+ return mla4(a[0], b[0], a[1], b[1], a[2], b[2], a[3], b[3]);
+}
+
+
+inline
+GLfixed dot3(const GLfixed* a, const GLfixed* b)
+{
+ return mla3(a[0], b[0], a[1], b[1], a[2], b[2]);
+}
+
+
+}; // namespace android
+
+#endif // ANDROID_OPENGLES_MATRIX_H
+
diff --git a/opengl/libagl/mipmap.cpp b/opengl/libagl/mipmap.cpp
new file mode 100644
index 0000000..ccd77b7
--- /dev/null
+++ b/opengl/libagl/mipmap.cpp
@@ -0,0 +1,192 @@
+/* libs/opengles/mipmap.cpp
+**
+** Copyright 2006, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+** http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+
+#include "context.h"
+#include "state.h"
+#include "texture.h"
+#include "TextureObjectManager.h"
+
+namespace android {
+
+// ----------------------------------------------------------------------------
+
+status_t buildAPyramid(ogles_context_t* c, EGLTextureObject* tex)
+{
+ int level = 0;
+ const GGLSurface* base = &tex->surface;
+ const GGLFormat& pixelFormat(c->rasterizer.formats[base->format]);
+
+ int w = base->width;
+ int h = base->height;
+ if ((w&h) == 1)
+ return NO_ERROR;
+
+ w = (w>>1) ? : 1;
+ h = (h>>1) ? : 1;
+
+ while(true) {
+ ++level;
+ const int bpr = w * pixelFormat.size;
+ if (tex->reallocate(level, w, h, w,
+ base->format, base->compressedFormat, bpr) != NO_ERROR) {
+ return NO_MEMORY;
+ }
+
+ int stride = w;
+ int bs = base->stride;
+ GGLSurface& cur = tex->editMip(level);
+
+ if (base->format == GGL_PIXEL_FORMAT_RGB_565)
+ {
+ uint16_t const * src = (uint16_t const *)base->data;
+ uint16_t* dst = (uint16_t*)cur.data;
+ const uint32_t mask = 0x07E0F81F;
+ for (int y=0 ; y<h ; y++) {
+ size_t offset = (y*2) * bs;
+ for (int x=0 ; x<w ; x++) {
+ uint32_t p00 = src[offset];
+ uint32_t p10 = src[offset+1];
+ uint32_t p01 = src[offset+bs];
+ uint32_t p11 = src[offset+bs+1];
+ p00 = (p00 | (p00 << 16)) & mask;
+ p01 = (p01 | (p01 << 16)) & mask;
+ p10 = (p10 | (p10 << 16)) & mask;
+ p11 = (p11 | (p11 << 16)) & mask;
+ uint32_t grb = ((p00 + p10 + p01 + p11) >> 2) & mask;
+ uint32_t rgb = (grb & 0xFFFF) | (grb >> 16);
+ dst[x + y*stride] = rgb;
+ offset += 2;
+ }
+ }
+ }
+ else if (base->format == GGL_PIXEL_FORMAT_RGBA_5551)
+ {
+ uint16_t const * src = (uint16_t const *)base->data;
+ uint16_t* dst = (uint16_t*)cur.data;
+ for (int y=0 ; y<h ; y++) {
+ size_t offset = (y*2) * bs;
+ for (int x=0 ; x<w ; x++) {
+ uint32_t p00 = src[offset];
+ uint32_t p10 = src[offset+1];
+ uint32_t p01 = src[offset+bs];
+ uint32_t p11 = src[offset+bs+1];
+ uint32_t r = ((p00>>11)+(p10>>11)+(p01>>11)+(p11>>11)+2)>>2;
+ uint32_t g = (((p00>>6)+(p10>>6)+(p01>>6)+(p11>>6)+2)>>2)&0x3F;
+ uint32_t b = ((p00&0x3E)+(p10&0x3E)+(p01&0x3E)+(p11&0x3E)+4)>>3;
+ uint32_t a = ((p00&1)+(p10&1)+(p01&1)+(p11&1)+2)>>2;
+ dst[x + y*stride] = (r<<11)|(g<<6)|(b<<1)|a;
+ offset += 2;
+ }
+ }
+ }
+ else if (base->format == GGL_PIXEL_FORMAT_RGBA_8888)
+ {
+ uint32_t const * src = (uint32_t const *)base->data;
+ uint32_t* dst = (uint32_t*)cur.data;
+ for (int y=0 ; y<h ; y++) {
+ size_t offset = (y*2) * bs;
+ for (int x=0 ; x<w ; x++) {
+ uint32_t p00 = src[offset];
+ uint32_t p10 = src[offset+1];
+ uint32_t p01 = src[offset+bs];
+ uint32_t p11 = src[offset+bs+1];
+ uint32_t rb00 = p00 & 0x00FF00FF;
+ uint32_t rb01 = p01 & 0x00FF00FF;
+ uint32_t rb10 = p10 & 0x00FF00FF;
+ uint32_t rb11 = p11 & 0x00FF00FF;
+ uint32_t ga00 = (p00 >> 8) & 0x00FF00FF;
+ uint32_t ga01 = (p01 >> 8) & 0x00FF00FF;
+ uint32_t ga10 = (p10 >> 8) & 0x00FF00FF;
+ uint32_t ga11 = (p11 >> 8) & 0x00FF00FF;
+ uint32_t rb = (rb00 + rb01 + rb10 + rb11)>>2;
+ uint32_t ga = (ga00 + ga01 + ga10 + ga11)>>2;
+ uint32_t rgba = (rb & 0x00FF00FF) | ((ga & 0x00FF00FF)<<8);
+ dst[x + y*stride] = rgba;
+ offset += 2;
+ }
+ }
+ }
+ else if ((base->format == GGL_PIXEL_FORMAT_RGB_888) ||
+ (base->format == GGL_PIXEL_FORMAT_LA_88) ||
+ (base->format == GGL_PIXEL_FORMAT_A_8) ||
+ (base->format == GGL_PIXEL_FORMAT_L_8))
+ {
+ int skip;
+ switch (base->format) {
+ case GGL_PIXEL_FORMAT_RGB_888: skip = 3; break;
+ case GGL_PIXEL_FORMAT_LA_88: skip = 2; break;
+ default: skip = 1; break;
+ }
+ uint8_t const * src = (uint8_t const *)base->data;
+ uint8_t* dst = (uint8_t*)cur.data;
+ bs *= skip;
+ stride *= skip;
+ for (int y=0 ; y<h ; y++) {
+ size_t offset = (y*2) * bs;
+ for (int x=0 ; x<w ; x++) {
+ for (int c=0 ; c<skip ; c++) {
+ uint32_t p00 = src[c+offset];
+ uint32_t p10 = src[c+offset+skip];
+ uint32_t p01 = src[c+offset+bs];
+ uint32_t p11 = src[c+offset+bs+skip];
+ dst[x + y*stride + c] = (p00 + p10 + p01 + p11) >> 2;
+ }
+ offset += 2*skip;
+ }
+ }
+ }
+ else if (base->format == GGL_PIXEL_FORMAT_RGBA_4444)
+ {
+ uint16_t const * src = (uint16_t const *)base->data;
+ uint16_t* dst = (uint16_t*)cur.data;
+ for (int y=0 ; y<h ; y++) {
+ size_t offset = (y*2) * bs;
+ for (int x=0 ; x<w ; x++) {
+ uint32_t p00 = src[offset];
+ uint32_t p10 = src[offset+1];
+ uint32_t p01 = src[offset+bs];
+ uint32_t p11 = src[offset+bs+1];
+ p00 = ((p00 << 12) & 0x0F0F0000) | (p00 & 0x0F0F);
+ p10 = ((p10 << 12) & 0x0F0F0000) | (p10 & 0x0F0F);
+ p01 = ((p01 << 12) & 0x0F0F0000) | (p01 & 0x0F0F);
+ p11 = ((p11 << 12) & 0x0F0F0000) | (p11 & 0x0F0F);
+ uint32_t rbga = (p00 + p10 + p01 + p11) >> 2;
+ uint32_t rgba = (rbga & 0x0F0F) | ((rbga>>12) & 0xF0F0);
+ dst[x + y*stride] = rgba;
+ offset += 2;
+ }
+ }
+ } else {
+ LOGE("Unsupported format (%d)", base->format);
+ return BAD_TYPE;
+ }
+
+ // exit condition: we just processed the 1x1 LODs
+ if ((w&h) == 1)
+ break;
+
+ base = &cur;
+ w = (w>>1) ? : 1;
+ h = (h>>1) ? : 1;
+ }
+ return NO_ERROR;
+}
+
+}; // namespace android
diff --git a/opengl/libagl/primitives.cpp b/opengl/libagl/primitives.cpp
new file mode 100644
index 0000000..f164c02
--- /dev/null
+++ b/opengl/libagl/primitives.cpp
@@ -0,0 +1,1111 @@
+/* libs/opengles/primitives.cpp
+**
+** Copyright 2006, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+** http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include <math.h>
+
+#include "context.h"
+#include "primitives.h"
+#include "light.h"
+#include "matrix.h"
+#include "vertex.h"
+#include "fp.h"
+#include "TextureObjectManager.h"
+
+extern "C" void iterators0032(const void* that,
+ int32_t* it, int32_t c0, int32_t c1, int32_t c2);
+
+namespace android {
+
+// ----------------------------------------------------------------------------
+
+static void primitive_point(ogles_context_t* c, vertex_t* v);
+static void primitive_line(ogles_context_t* c, vertex_t* v0, vertex_t* v1);
+static void primitive_clip_triangle(ogles_context_t* c,
+ vertex_t* v0, vertex_t* v1, vertex_t* v2);
+
+static void primitive_nop_point(ogles_context_t* c, vertex_t* v);
+static void primitive_nop_line(ogles_context_t* c, vertex_t* v0, vertex_t* v1);
+static void primitive_nop_triangle(ogles_context_t* c,
+ vertex_t* v0, vertex_t* v1, vertex_t* v2);
+
+static inline bool cull_triangle(ogles_context_t* c,
+ vertex_t* v0, vertex_t* v1, vertex_t* v2);
+
+static void lerp_triangle(ogles_context_t* c,
+ vertex_t* v0, vertex_t* v1, vertex_t* v2);
+
+static void lerp_texcoords(ogles_context_t* c,
+ vertex_t* v0, vertex_t* v1, vertex_t* v2);
+
+static void lerp_texcoords_w(ogles_context_t* c,
+ vertex_t* v0, vertex_t* v1, vertex_t* v2);
+
+static void triangle(ogles_context_t* c,
+ vertex_t* v0, vertex_t* v1, vertex_t* v2);
+
+static void clip_triangle(ogles_context_t* c,
+ vertex_t* v0, vertex_t* v1, vertex_t* v2);
+
+static unsigned int clip_line(ogles_context_t* c,
+ vertex_t* s, vertex_t* p);
+
+// ----------------------------------------------------------------------------
+#if 0
+#pragma mark -
+#endif
+
+static void lightTriangleDarkSmooth(ogles_context_t* c,
+ vertex_t* v0, vertex_t* v1, vertex_t* v2)
+{
+ if (!(v0->flags & vertex_t::LIT)) {
+ v0->flags |= vertex_t::LIT;
+ const GLvoid* cp = c->arrays.color.element(
+ v0->index & vertex_cache_t::INDEX_MASK);
+ c->arrays.color.fetch(c, v0->color.v, cp);
+ }
+ if (!(v1->flags & vertex_t::LIT)) {
+ v1->flags |= vertex_t::LIT;
+ const GLvoid* cp = c->arrays.color.element(
+ v1->index & vertex_cache_t::INDEX_MASK);
+ c->arrays.color.fetch(c, v1->color.v, cp);
+ }
+ if(!(v2->flags & vertex_t::LIT)) {
+ v2->flags |= vertex_t::LIT;
+ const GLvoid* cp = c->arrays.color.element(
+ v2->index & vertex_cache_t::INDEX_MASK);
+ c->arrays.color.fetch(c, v2->color.v, cp);
+ }
+}
+
+static void lightTriangleDarkFlat(ogles_context_t* c,
+ vertex_t* v0, vertex_t* v1, vertex_t* v2)
+{
+ if (!(v2->flags & vertex_t::LIT)) {
+ v2->flags |= vertex_t::LIT;
+ const GLvoid* cp = c->arrays.color.element(
+ v2->index & vertex_cache_t::INDEX_MASK);
+ c->arrays.color.fetch(c, v2->color.v, cp);
+ }
+ // configure the rasterizer here, before we clip
+ c->rasterizer.procs.color4xv(c, v2->color.v);
+}
+
+static void lightTriangleSmooth(ogles_context_t* c,
+ vertex_t* v0, vertex_t* v1, vertex_t* v2)
+{
+ if (!(v0->flags & vertex_t::LIT))
+ c->lighting.lightVertex(c, v0);
+ if (!(v1->flags & vertex_t::LIT))
+ c->lighting.lightVertex(c, v1);
+ if(!(v2->flags & vertex_t::LIT))
+ c->lighting.lightVertex(c, v2);
+}
+
+static void lightTriangleFlat(ogles_context_t* c,
+ vertex_t* v0, vertex_t* v1, vertex_t* v2)
+{
+ if (!(v2->flags & vertex_t::LIT))
+ c->lighting.lightVertex(c, v2);
+ // configure the rasterizer here, before we clip
+ c->rasterizer.procs.color4xv(c, v2->color.v);
+}
+
+// The fog versions...
+
+static inline
+void lightVertexDarkSmoothFog(ogles_context_t* c, vertex_t* v)
+{
+ if (!(v->flags & vertex_t::LIT)) {
+ v->flags |= vertex_t::LIT;
+ v->fog = c->fog.fog(c, v->eye.z);
+ const GLvoid* cp = c->arrays.color.element(
+ v->index & vertex_cache_t::INDEX_MASK);
+ c->arrays.color.fetch(c, v->color.v, cp);
+ }
+}
+static inline
+void lightVertexDarkFlatFog(ogles_context_t* c, vertex_t* v)
+{
+ if (!(v->flags & vertex_t::LIT)) {
+ v->flags |= vertex_t::LIT;
+ v->fog = c->fog.fog(c, v->eye.z);
+ }
+}
+static inline
+void lightVertexSmoothFog(ogles_context_t* c, vertex_t* v)
+{
+ if (!(v->flags & vertex_t::LIT)) {
+ v->fog = c->fog.fog(c, v->eye.z);
+ c->lighting.lightVertex(c, v);
+ }
+}
+
+static void lightTriangleDarkSmoothFog(ogles_context_t* c,
+ vertex_t* v0, vertex_t* v1, vertex_t* v2)
+{
+ lightVertexDarkSmoothFog(c, v0);
+ lightVertexDarkSmoothFog(c, v1);
+ lightVertexDarkSmoothFog(c, v2);
+}
+
+static void lightTriangleDarkFlatFog(ogles_context_t* c,
+ vertex_t* v0, vertex_t* v1, vertex_t* v2)
+{
+ lightVertexDarkFlatFog(c, v0);
+ lightVertexDarkFlatFog(c, v1);
+ lightVertexDarkSmoothFog(c, v2);
+ // configure the rasterizer here, before we clip
+ c->rasterizer.procs.color4xv(c, v2->color.v);
+}
+
+static void lightTriangleSmoothFog(ogles_context_t* c,
+ vertex_t* v0, vertex_t* v1, vertex_t* v2)
+{
+ lightVertexSmoothFog(c, v0);
+ lightVertexSmoothFog(c, v1);
+ lightVertexSmoothFog(c, v2);
+}
+
+static void lightTriangleFlatFog(ogles_context_t* c,
+ vertex_t* v0, vertex_t* v1, vertex_t* v2)
+{
+ lightVertexDarkFlatFog(c, v0);
+ lightVertexDarkFlatFog(c, v1);
+ lightVertexSmoothFog(c, v2);
+ // configure the rasterizer here, before we clip
+ c->rasterizer.procs.color4xv(c, v2->color.v);
+}
+
+
+
+typedef void (*light_primitive_t)(ogles_context_t*,
+ vertex_t*, vertex_t*, vertex_t*);
+
+// fog 0x4, light 0x2, smooth 0x1
+static const light_primitive_t lightPrimitive[8] = {
+ lightTriangleDarkFlat, // no fog | dark | flat
+ lightTriangleDarkSmooth, // no fog | dark | smooth
+ lightTriangleFlat, // no fog | light | flat
+ lightTriangleSmooth, // no fog | light | smooth
+ lightTriangleDarkFlatFog, // fog | dark | flat
+ lightTriangleDarkSmoothFog, // fog | dark | smooth
+ lightTriangleFlatFog, // fog | light | flat
+ lightTriangleSmoothFog // fog | light | smooth
+};
+
+void ogles_validate_primitives(ogles_context_t* c)
+{
+ const uint32_t enables = c->rasterizer.state.enables;
+
+ // set up the lighting/shading/smoothing/fogging function
+ int index = enables & GGL_ENABLE_SMOOTH ? 0x1 : 0;
+ index |= c->lighting.enable ? 0x2 : 0;
+ index |= enables & GGL_ENABLE_FOG ? 0x4 : 0;
+ c->lighting.lightTriangle = lightPrimitive[index];
+
+ // set up the primitive renderers
+ if (ggl_likely(c->arrays.vertex.enable)) {
+ c->prims.renderPoint = primitive_point;
+ c->prims.renderLine = primitive_line;
+ c->prims.renderTriangle = primitive_clip_triangle;
+ } else {
+ c->prims.renderPoint = primitive_nop_point;
+ c->prims.renderLine = primitive_nop_line;
+ c->prims.renderTriangle = primitive_nop_triangle;
+ }
+}
+
+// ----------------------------------------------------------------------------
+
+void compute_iterators_t::initTriangle(
+ vertex_t const* v0, vertex_t const* v1, vertex_t const* v2)
+{
+ m_dx01 = v1->window.x - v0->window.x;
+ m_dy10 = v0->window.y - v1->window.y;
+ m_dx20 = v0->window.x - v2->window.x;
+ m_dy02 = v2->window.y - v0->window.y;
+ m_area = m_dx01*m_dy02 + (-m_dy10)*m_dx20;
+}
+
+void compute_iterators_t::initLine(
+ vertex_t const* v0, vertex_t const* v1)
+{
+ m_dx01 = m_dy02 = v1->window.x - v0->window.x;
+ m_dy10 = m_dx20 = v0->window.y - v1->window.y;
+ m_area = m_dx01*m_dy02 + (-m_dy10)*m_dx20;
+}
+
+void compute_iterators_t::initLerp(vertex_t const* v0, uint32_t enables)
+{
+ m_x0 = v0->window.x;
+ m_y0 = v0->window.y;
+ const GGLcoord area = (m_area + TRI_HALF) >> TRI_FRACTION_BITS;
+ const GGLcoord minArea = 2; // cannot be inverted
+ // triangles with an area smaller than 1.0 are not smooth-shaded
+
+ int q=0, s=0, d=0;
+ if (abs(area) >= minArea) {
+ // Here we do some voodoo magic, to compute a suitable scale
+ // factor for deltas/area:
+
+ // First compute the 1/area with full 32-bits precision,
+ // gglRecipQNormalized returns a number [-0.5, 0.5[ and an exponent.
+ d = gglRecipQNormalized(area, &q);
+
+ // Then compute the minimum left-shift to not overflow the muls
+ // below.
+ s = 32 - gglClz(abs(m_dy02)|abs(m_dy10)|abs(m_dx01)|abs(m_dx20));
+
+ // We'll keep 16-bits of precision for deltas/area. So we need
+ // to shift everything left an extra 15 bits.
+ s += 15;
+
+ // make sure all final shifts are not > 32, because gglMulx
+ // can't handle it.
+ if (s < q) s = q;
+ if (s > 32) {
+ d >>= 32-s;
+ s = 32;
+ }
+ }
+
+ m_dx01 = gglMulx(m_dx01, d, s);
+ m_dy10 = gglMulx(m_dy10, d, s);
+ m_dx20 = gglMulx(m_dx20, d, s);
+ m_dy02 = gglMulx(m_dy02, d, s);
+ m_area_scale = 32 + q - s;
+ m_scale = 0;
+
+ if (enables & GGL_ENABLE_TMUS) {
+ const int A = gglClz(abs(m_dy02)|abs(m_dy10)|abs(m_dx01)|abs(m_dx20));
+ const int B = gglClz(abs(m_x0)|abs(m_y0));
+ m_scale = max(0, 32 - (A + 16)) +
+ max(0, 32 - (B + TRI_FRACTION_BITS)) + 1;
+ }
+}
+
+int compute_iterators_t::iteratorsScale(GGLfixed* it,
+ int32_t c0, int32_t c1, int32_t c2) const
+{
+ int32_t dc01 = c1 - c0;
+ int32_t dc02 = c2 - c0;
+ const int A = gglClz(abs(c0));
+ const int B = gglClz(abs(dc01)|abs(dc02));
+ const int scale = min(A, B - m_scale) - 2;
+ if (scale >= 0) {
+ c0 <<= scale;
+ dc01 <<= scale;
+ dc02 <<= scale;
+ } else {
+ c0 >>= -scale;
+ dc01 >>= -scale;
+ dc02 >>= -scale;
+ }
+ const int s = m_area_scale;
+ int32_t dcdx = gglMulAddx(dc01, m_dy02, gglMulx(dc02, m_dy10, s), s);
+ int32_t dcdy = gglMulAddx(dc02, m_dx01, gglMulx(dc01, m_dx20, s), s);
+ int32_t c = c0 - (gglMulAddx(dcdx, m_x0,
+ gglMulx(dcdy, m_y0, TRI_FRACTION_BITS), TRI_FRACTION_BITS));
+ it[0] = c;
+ it[1] = dcdx;
+ it[2] = dcdy;
+ return scale;
+}
+
+void compute_iterators_t::iterators1616(GGLfixed* it,
+ GGLfixed c0, GGLfixed c1, GGLfixed c2) const
+{
+ const GGLfixed dc01 = c1 - c0;
+ const GGLfixed dc02 = c2 - c0;
+ // 16.16 x 16.16 == 32.32 --> 16.16
+ const int s = m_area_scale;
+ int32_t dcdx = gglMulAddx(dc01, m_dy02, gglMulx(dc02, m_dy10, s), s);
+ int32_t dcdy = gglMulAddx(dc02, m_dx01, gglMulx(dc01, m_dx20, s), s);
+ int32_t c = c0 - (gglMulAddx(dcdx, m_x0,
+ gglMulx(dcdy, m_y0, TRI_FRACTION_BITS), TRI_FRACTION_BITS));
+ it[0] = c;
+ it[1] = dcdx;
+ it[2] = dcdy;
+}
+
+void compute_iterators_t::iterators0032(int64_t* it,
+ int32_t c0, int32_t c1, int32_t c2) const
+{
+ const int s = m_area_scale - 16;
+ int32_t dc01 = (c1 - c0)>>s;
+ int32_t dc02 = (c2 - c0)>>s;
+ // 16.16 x 16.16 == 32.32
+ int64_t dcdx = gglMulii(dc01, m_dy02) + gglMulii(dc02, m_dy10);
+ int64_t dcdy = gglMulii(dc02, m_dx01) + gglMulii(dc01, m_dx20);
+ it[ 0] = (c0<<16) - ((dcdx*m_x0 + dcdy*m_y0)>>4);
+ it[ 1] = dcdx;
+ it[ 2] = dcdy;
+}
+
+#if defined(__arm__) && !defined(__thumb__)
+inline void compute_iterators_t::iterators0032(int32_t* it,
+ int32_t c0, int32_t c1, int32_t c2) const
+{
+ ::iterators0032(this, it, c0, c1, c2);
+}
+#else
+void compute_iterators_t::iterators0032(int32_t* it,
+ int32_t c0, int32_t c1, int32_t c2) const
+{
+ int64_t it64[3];
+ iterators0032(it, c0, c1, c2);
+ it[0] = it64[0];
+ it[1] = it64[1];
+ it[2] = it64[2];
+}
+#endif
+
+// ----------------------------------------------------------------------------
+
+static inline int32_t clampZ(GLfixed z) CONST;
+int32_t clampZ(GLfixed z) {
+ z = (z & ~(z>>31));
+ if (z >= 0x10000)
+ z = 0xFFFF;
+ return z;
+}
+
+static __attribute__((noinline))
+void fetch_texcoord_impl(ogles_context_t* c,
+ vertex_t* v0, vertex_t* v1, vertex_t* v2)
+{
+ vertex_t* const vtx[3] = { v0, v1, v2 };
+ array_t const * const texcoordArray = c->arrays.texture;
+
+ for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; i++) {
+ if (!(c->rasterizer.state.texture[i].enable))
+ continue;
+
+ for (int j=0 ; j<3 ; j++) {
+ vertex_t* const v = vtx[j];
+ if (v->flags & vertex_t::TT)
+ continue;
+
+ // NOTE: here we could compute automatic texgen
+ // such as sphere/cube maps, instead of fetching them
+ // from the textcoord array.
+
+ vec4_t& coords = v->texture[i];
+ const GLubyte* tp = texcoordArray[i].element(
+ v->index & vertex_cache_t::INDEX_MASK);
+ texcoordArray[i].fetch(c, coords.v, tp);
+
+ // transform texture coordinates...
+ coords.Q = 0x10000;
+ const transform_t& tr = c->transforms.texture[i].transform;
+ if (ggl_unlikely(tr.ops)) {
+ c->arrays.tex_transform[i](&tr, &coords, &coords);
+ }
+
+ // divide by Q
+ const GGLfixed q = coords.Q;
+ if (ggl_unlikely(q != 0x10000)) {
+ const int32_t qinv = gglRecip28(q);
+ coords.S = gglMulx(coords.S, qinv, 28);
+ coords.T = gglMulx(coords.T, qinv, 28);
+ }
+ }
+ }
+ v0->flags |= vertex_t::TT;
+ v1->flags |= vertex_t::TT;
+ v2->flags |= vertex_t::TT;
+}
+
+inline void fetch_texcoord(ogles_context_t* c,
+ vertex_t* v0, vertex_t* v1, vertex_t* v2)
+{
+ const uint32_t enables = c->rasterizer.state.enables;
+ if (!(enables & GGL_ENABLE_TMUS))
+ return;
+
+ // Fetch & transform texture coordinates...
+ if (ggl_likely(v0->flags & v1->flags & v2->flags & vertex_t::TT)) {
+ // already done for all three vertices, bail...
+ return;
+ }
+ fetch_texcoord_impl(c, v0, v1, v2);
+}
+
+// ----------------------------------------------------------------------------
+#if 0
+#pragma mark -
+#pragma mark Point
+#endif
+
+void primitive_nop_point(ogles_context_t*, vertex_t*) {
+}
+
+void primitive_point(ogles_context_t* c, vertex_t* v)
+{
+ // lighting & clamping...
+ const uint32_t enables = c->rasterizer.state.enables;
+
+ if (ggl_unlikely(!(v->flags & vertex_t::LIT))) {
+ if (c->lighting.enable) {
+ c->lighting.lightVertex(c, v);
+ } else {
+ v->flags |= vertex_t::LIT;
+ const GLvoid* cp = c->arrays.color.element(
+ v->index & vertex_cache_t::INDEX_MASK);
+ c->arrays.color.fetch(c, v->color.v, cp);
+ }
+ if (enables & GGL_ENABLE_FOG) {
+ v->fog = c->fog.fog(c, v->eye.z);
+ }
+ }
+
+ // XXX: we don't need to do that each-time
+ // if color array and lighting not enabled
+ c->rasterizer.procs.color4xv(c, v->color.v);
+
+ // XXX: look into ES point-sprite extension
+ if (enables & GGL_ENABLE_TMUS) {
+ fetch_texcoord(c, v,v,v);
+ for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; i++) {
+ if (!c->rasterizer.state.texture[i].enable)
+ continue;
+ int32_t itt[8];
+ itt[1] = itt[2] = itt[4] = itt[5] = 0;
+ itt[6] = itt[7] = 16; // XXX: check that
+ if (c->rasterizer.state.texture[i].s_wrap == GGL_CLAMP) {
+ int width = c->textures.tmu[i].texture->surface.width;
+ itt[0] = v->texture[i].S * width;
+ itt[6] = 0;
+ }
+ if (c->rasterizer.state.texture[i].t_wrap == GGL_CLAMP) {
+ int height = c->textures.tmu[i].texture->surface.height;
+ itt[3] = v->texture[i].T * height;
+ itt[7] = 0;
+ }
+ c->rasterizer.procs.texCoordGradScale8xv(c, i, itt);
+ }
+ }
+
+ if (enables & GGL_ENABLE_DEPTH_TEST) {
+ int32_t itz[3];
+ itz[0] = clampZ(v->window.z) * 0x00010001;
+ itz[1] = itz[2] = 0;
+ c->rasterizer.procs.zGrad3xv(c, itz);
+ }
+
+ if (enables & GGL_ENABLE_FOG) {
+ GLfixed itf[3];
+ itf[0] = v->fog;
+ itf[1] = itf[2] = 0;
+ c->rasterizer.procs.fogGrad3xv(c, itf);
+ }
+
+ // Render our point...
+ c->rasterizer.procs.pointx(c, v->window.v, c->point.size);
+}
+
+// ----------------------------------------------------------------------------
+#if 0
+#pragma mark -
+#pragma mark Line
+#endif
+
+void primitive_nop_line(ogles_context_t*, vertex_t*, vertex_t*) {
+}
+
+void primitive_line(ogles_context_t* c, vertex_t* v0, vertex_t* v1)
+{
+ // get texture coordinates
+ fetch_texcoord(c, v0, v1, v1);
+
+ // light/shade the vertices first (they're copied below)
+ c->lighting.lightTriangle(c, v0, v1, v1);
+
+ // clip the line if needed
+ if (ggl_unlikely((v0->flags | v1->flags) & vertex_t::CLIP_ALL)) {
+ unsigned int count = clip_line(c, v0, v1);
+ if (ggl_unlikely(count == 0))
+ return;
+ }
+
+ // compute iterators...
+ const uint32_t enables = c->rasterizer.state.enables;
+ const uint32_t mask = GGL_ENABLE_TMUS |
+ GGL_ENABLE_SMOOTH |
+ GGL_ENABLE_W |
+ GGL_ENABLE_FOG |
+ GGL_ENABLE_DEPTH_TEST;
+
+ if (ggl_unlikely(enables & mask)) {
+ c->lerp.initLine(v0, v1);
+ lerp_triangle(c, v0, v1, v0);
+ }
+
+ // render our line
+ c->rasterizer.procs.linex(c, v0->window.v, v1->window.v, c->line.width);
+}
+
+// ----------------------------------------------------------------------------
+#if 0
+#pragma mark -
+#pragma mark Triangle
+#endif
+
+void primitive_nop_triangle(ogles_context_t* c,
+ vertex_t* v0, vertex_t* v1, vertex_t* v2) {
+}
+
+void primitive_clip_triangle(ogles_context_t* c,
+ vertex_t* v0, vertex_t* v1, vertex_t* v2)
+{
+ uint32_t cc = (v0->flags | v1->flags | v2->flags) & vertex_t::CLIP_ALL;
+ if (ggl_likely(!cc)) {
+ // code below must be as optimized as possible, this is the
+ // common code path.
+
+ // This triangle is not clipped, test if it's culled
+ // unclipped triangle...
+ c->lerp.initTriangle(v0, v1, v2);
+ if (cull_triangle(c, v0, v1, v2))
+ return; // culled!
+
+ // Fetch all texture coordinates if needed
+ fetch_texcoord(c, v0, v1, v2);
+
+ // light (or shade) our triangle!
+ c->lighting.lightTriangle(c, v0, v1, v2);
+
+ triangle(c, v0, v1, v2);
+ return;
+ }
+
+ // The assumption here is that we're not going to clip very often,
+ // and even more rarely will we clip a triangle that ends up
+ // being culled out. So it's okay to light the vertices here, even though
+ // in a few cases we won't render the triangle (if culled).
+
+ // Fetch texture coordinates...
+ fetch_texcoord(c, v0, v1, v2);
+
+ // light (or shade) our triangle!
+ c->lighting.lightTriangle(c, v0, v1, v2);
+
+ clip_triangle(c, v0, v1, v2);
+}
+
+// -----------------------------------------------------------------------
+
+void triangle(ogles_context_t* c,
+ vertex_t* v0, vertex_t* v1, vertex_t* v2)
+{
+ // compute iterators...
+ const uint32_t enables = c->rasterizer.state.enables;
+ const uint32_t mask = GGL_ENABLE_TMUS |
+ GGL_ENABLE_SMOOTH |
+ GGL_ENABLE_W |
+ GGL_ENABLE_FOG |
+ GGL_ENABLE_DEPTH_TEST;
+
+ if (ggl_likely(enables & mask))
+ lerp_triangle(c, v0, v1, v2);
+
+ c->rasterizer.procs.trianglex(c, v0->window.v, v1->window.v, v2->window.v);
+}
+
+void lerp_triangle(ogles_context_t* c,
+ vertex_t* v0, vertex_t* v1, vertex_t* v2)
+{
+ const uint32_t enables = c->rasterizer.state.enables;
+ c->lerp.initLerp(v0, enables);
+
+ // set up texture iterators
+ if (enables & GGL_ENABLE_TMUS) {
+ if (enables & GGL_ENABLE_W) {
+ lerp_texcoords_w(c, v0, v1, v2);
+ } else {
+ lerp_texcoords(c, v0, v1, v2);
+ }
+ }
+
+ // set up the color iterators
+ const compute_iterators_t& lerp = c->lerp;
+ if (enables & GGL_ENABLE_SMOOTH) {
+ GLfixed itc[12];
+ for (int i=0 ; i<4 ; i++) {
+ const GGLcolor c0 = v0->color.v[i] * 255;
+ const GGLcolor c1 = v1->color.v[i] * 255;
+ const GGLcolor c2 = v2->color.v[i] * 255;
+ lerp.iterators1616(&itc[i*3], c0, c1, c2);
+ }
+ c->rasterizer.procs.colorGrad12xv(c, itc);
+ }
+
+ if (enables & GGL_ENABLE_DEPTH_TEST) {
+ int32_t itz[3];
+ const int32_t v0z = clampZ(v0->window.z);
+ const int32_t v1z = clampZ(v1->window.z);
+ const int32_t v2z = clampZ(v2->window.z);
+ if (ggl_unlikely(c->polygonOffset.enable)) {
+ const int32_t units = (c->polygonOffset.units << 16);
+ const GLfixed factor = c->polygonOffset.factor;
+ if (factor) {
+ int64_t itz64[3];
+ lerp.iterators0032(itz64, v0z, v1z, v2z);
+ int64_t maxDepthSlope = max(itz64[1], itz64[2]);
+ itz[0] = uint32_t(itz64[0])
+ + uint32_t((maxDepthSlope*factor)>>16) + units;
+ itz[1] = uint32_t(itz64[1]);
+ itz[2] = uint32_t(itz64[2]);
+ } else {
+ lerp.iterators0032(itz, v0z, v1z, v2z);
+ itz[0] += units;
+ }
+ } else {
+ lerp.iterators0032(itz, v0z, v1z, v2z);
+ }
+ c->rasterizer.procs.zGrad3xv(c, itz);
+ }
+
+ if (ggl_unlikely(enables & GGL_ENABLE_FOG)) {
+ GLfixed itf[3];
+ lerp.iterators1616(itf, v0->fog, v1->fog, v2->fog);
+ c->rasterizer.procs.fogGrad3xv(c, itf);
+ }
+}
+
+
+static inline
+int compute_lod(ogles_context_t* c, int i,
+ int32_t s0, int32_t t0, int32_t s1, int32_t t1, int32_t s2, int32_t t2)
+{
+ // Compute mipmap level / primitive
+ // rho = sqrt( texelArea / area )
+ // lod = log2( rho )
+ // lod = log2( texelArea / area ) / 2
+ // lod = (log2( texelArea ) - log2( area )) / 2
+ const compute_iterators_t& lerp = c->lerp;
+ const GGLcoord area = abs(lerp.area());
+ const int w = c->textures.tmu[i].texture->surface.width;
+ const int h = c->textures.tmu[i].texture->surface.height;
+ const int shift = 16 + (16 - TRI_FRACTION_BITS);
+ int32_t texelArea = abs( gglMulx(s1-s0, t2-t0, shift) -
+ gglMulx(s2-s0, t1-t0, shift) )*w*h;
+ int log2TArea = (32-TRI_FRACTION_BITS -1) - gglClz(texelArea);
+ int log2Area = (32-TRI_FRACTION_BITS*2-1) - gglClz(area);
+ int lod = (log2TArea - log2Area + 1) >> 1;
+ return lod;
+}
+
+void lerp_texcoords(ogles_context_t* c,
+ vertex_t* v0, vertex_t* v1, vertex_t* v2)
+{
+ const compute_iterators_t& lerp = c->lerp;
+ int32_t itt[8] __attribute__((aligned(16)));
+ for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; i++) {
+ const texture_t& tmu = c->rasterizer.state.texture[i];
+ if (!tmu.enable)
+ continue;
+
+ // compute the jacobians using block floating-point
+ int32_t s0 = v0->texture[i].S;
+ int32_t t0 = v0->texture[i].T;
+ int32_t s1 = v1->texture[i].S;
+ int32_t t1 = v1->texture[i].T;
+ int32_t s2 = v2->texture[i].S;
+ int32_t t2 = v2->texture[i].T;
+
+ const GLenum min_filter = c->textures.tmu[i].texture->min_filter;
+ if (ggl_unlikely(min_filter >= GL_NEAREST_MIPMAP_NEAREST)) {
+ int lod = compute_lod(c, i, s0, t0, s1, t1, s2, t2);
+ c->rasterizer.procs.bindTextureLod(c, i,
+ &c->textures.tmu[i].texture->mip(lod));
+ }
+
+ // premultiply (s,t) when clampling
+ if (tmu.s_wrap == GGL_CLAMP) {
+ const int width = tmu.surface.width;
+ s0 *= width;
+ s1 *= width;
+ s2 *= width;
+ }
+ if (tmu.t_wrap == GGL_CLAMP) {
+ const int height = tmu.surface.height;
+ t0 *= height;
+ t1 *= height;
+ t2 *= height;
+ }
+ itt[6] = -lerp.iteratorsScale(itt+0, s0, s1, s2);
+ itt[7] = -lerp.iteratorsScale(itt+3, t0, t1, t2);
+ c->rasterizer.procs.texCoordGradScale8xv(c, i, itt);
+ }
+}
+
+void lerp_texcoords_w(ogles_context_t* c,
+ vertex_t* v0, vertex_t* v1, vertex_t* v2)
+{
+ const compute_iterators_t& lerp = c->lerp;
+ int32_t itt[8] __attribute__((aligned(16)));
+ int32_t itw[3];
+
+ // compute W's scale to 2.30
+ int32_t w0 = v0->window.w;
+ int32_t w1 = v1->window.w;
+ int32_t w2 = v2->window.w;
+ int wscale = 32 - gglClz(w0|w1|w2);
+
+ // compute the jacobian using block floating-point
+ int sc = lerp.iteratorsScale(itw, w0, w1, w2);
+ sc += wscale - 16;
+ c->rasterizer.procs.wGrad3xv(c, itw);
+
+ for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; i++) {
+ const texture_t& tmu = c->rasterizer.state.texture[i];
+ if (!tmu.enable)
+ continue;
+
+ // compute the jacobians using block floating-point
+ int32_t s0 = v0->texture[i].S;
+ int32_t t0 = v0->texture[i].T;
+ int32_t s1 = v1->texture[i].S;
+ int32_t t1 = v1->texture[i].T;
+ int32_t s2 = v2->texture[i].S;
+ int32_t t2 = v2->texture[i].T;
+
+ const GLenum min_filter = c->textures.tmu[i].texture->min_filter;
+ if (ggl_unlikely(min_filter >= GL_NEAREST_MIPMAP_NEAREST)) {
+ int lod = compute_lod(c, i, s0, t0, s1, t1, s2, t2);
+ c->rasterizer.procs.bindTextureLod(c, i,
+ &c->textures.tmu[i].texture->mip(lod));
+ }
+
+ // premultiply (s,t) when clampling
+ if (tmu.s_wrap == GGL_CLAMP) {
+ const int width = tmu.surface.width;
+ s0 *= width;
+ s1 *= width;
+ s2 *= width;
+ }
+ if (tmu.t_wrap == GGL_CLAMP) {
+ const int height = tmu.surface.height;
+ t0 *= height;
+ t1 *= height;
+ t2 *= height;
+ }
+
+ s0 = gglMulx(s0, w0, wscale);
+ t0 = gglMulx(t0, w0, wscale);
+ s1 = gglMulx(s1, w1, wscale);
+ t1 = gglMulx(t1, w1, wscale);
+ s2 = gglMulx(s2, w2, wscale);
+ t2 = gglMulx(t2, w2, wscale);
+
+ itt[6] = sc - lerp.iteratorsScale(itt+0, s0, s1, s2);
+ itt[7] = sc - lerp.iteratorsScale(itt+3, t0, t1, t2);
+ c->rasterizer.procs.texCoordGradScale8xv(c, i, itt);
+ }
+}
+
+
+static inline
+bool cull_triangle(ogles_context_t* c, vertex_t* v0, vertex_t* v1, vertex_t* v2)
+{
+ if (ggl_likely(c->cull.enable)) {
+ const GLenum winding = (c->lerp.area() > 0) ? GL_CW : GL_CCW;
+ const GLenum face = (winding == c->cull.frontFace) ? GL_FRONT : GL_BACK;
+ if (face == c->cull.cullFace)
+ return true; // culled!
+ }
+ return false;
+}
+
+static inline
+GLfixed frustumPlaneDist(int plane, const vec4_t& s)
+{
+ const GLfixed d = s.v[ plane >> 1 ];
+ return ((plane & 1) ? (s.w - d) : (s.w + d));
+}
+
+static inline
+int32_t clipDivide(GLfixed a, GLfixed b) {
+ // returns a 4.28 fixed-point
+ return gglMulDivi(1LU<<28, a, b);
+}
+
+void clip_triangle(ogles_context_t* c,
+ vertex_t* v0, vertex_t* v1, vertex_t* v2)
+{
+ uint32_t all_cc = (v0->flags | v1->flags | v2->flags) & vertex_t::CLIP_ALL;
+
+ vertex_t *p0, *p1, *p2;
+ const int MAX_CLIPPING_PLANES = 6 + OGLES_MAX_CLIP_PLANES;
+ const int MAX_VERTICES = 3;
+
+ // Temporary buffer to hold the new vertices. Each plane can add up to
+ // two new vertices (because the polygon is convex).
+ // We need one extra element, to handle an overflow case when
+ // the polygon degenerates into something non convex.
+ vertex_t buffer[MAX_CLIPPING_PLANES * 2 + 1]; // ~3KB
+ vertex_t* buf = buffer;
+
+ // original list of vertices (polygon to clip, in fact this
+ // function works with an arbitrary polygon).
+ vertex_t* in[3] = { v0, v1, v2 };
+
+ // output lists (we need 2, which we use back and forth)
+ // (maximum outpout list's size is MAX_CLIPPING_PLANES + MAX_VERTICES)
+ // 2 more elements for overflow when non convex polygons.
+ vertex_t* out[2][MAX_CLIPPING_PLANES + MAX_VERTICES + 2];
+ unsigned int outi = 0;
+
+ // current input list
+ vertex_t** ivl = in;
+
+ // 3 input vertices, 0 in the output list, first plane
+ unsigned int ic = 3;
+
+ // User clip-planes first, the clipping is always done in eye-coordinate
+ // this is basically the same algorithm than for the view-volume
+ // clipping, except for the computation of the distance (vertex, plane)
+ // and the fact that we need to compute the eye-coordinates of each
+ // new vertex we create.
+
+ if (ggl_unlikely(all_cc & vertex_t::USER_CLIP_ALL))
+ {
+ unsigned int plane = 0;
+ uint32_t cc = (all_cc & vertex_t::USER_CLIP_ALL) >> 8;
+ do {
+ if (cc & 1) {
+ // pointers to our output list (head and current)
+ vertex_t** const ovl = &out[outi][0];
+ vertex_t** output = ovl;
+ unsigned int oc = 0;
+ unsigned int sentinel = 0;
+ // previous vertex, compute distance to the plane
+ vertex_t* s = ivl[ic-1];
+ const vec4_t& equation = c->clipPlanes.plane[plane].equation;
+ GLfixed sd = dot4(equation.v, s->eye.v);
+ // clip each vertex against this plane...
+ for (unsigned int i=0 ; i<ic ; i++) {
+ vertex_t* p = ivl[i];
+ const GLfixed pd = dot4(equation.v, p->eye.v);
+ if (sd >= 0) {
+ if (pd >= 0) {
+ // both inside
+ *output++ = p;
+ oc++;
+ } else {
+ // s inside, p outside (exiting)
+ const GLfixed t = clipDivide(sd, sd-pd);
+ c->arrays.clipEye(c, buf, t, p, s);
+ *output++ = buf++;
+ oc++;
+ if (++sentinel >= 3)
+ return; // non-convex polygon!
+ }
+ } else {
+ if (pd >= 0) {
+ // s outside (entering)
+ if (pd) {
+ const GLfixed t = clipDivide(pd, pd-sd);
+ c->arrays.clipEye(c, buf, t, s, p);
+ *output++ = buf++;
+ oc++;
+ if (++sentinel >= 3)
+ return; // non-convex polygon!
+ }
+ *output++ = p;
+ oc++;
+ } else {
+ // both outside
+ }
+ }
+ s = p;
+ sd = pd;
+ }
+ // output list become the new input list
+ if (oc<3)
+ return; // less than 3 vertices left? we're done!
+ ivl = ovl;
+ ic = oc;
+ outi = 1-outi;
+ }
+ cc >>= 1;
+ plane++;
+ } while (cc);
+ }
+
+ // frustum clip-planes
+ if (all_cc & vertex_t::FRUSTUM_CLIP_ALL)
+ {
+ unsigned int plane = 0;
+ uint32_t cc = all_cc & vertex_t::FRUSTUM_CLIP_ALL;
+ do {
+ if (cc & 1) {
+ // pointers to our output list (head and current)
+ vertex_t** const ovl = &out[outi][0];
+ vertex_t** output = ovl;
+ unsigned int oc = 0;
+ unsigned int sentinel = 0;
+ // previous vertex, compute distance to the plane
+ vertex_t* s = ivl[ic-1];
+ GLfixed sd = frustumPlaneDist(plane, s->clip);
+ // clip each vertex against this plane...
+ for (unsigned int i=0 ; i<ic ; i++) {
+ vertex_t* p = ivl[i];
+ const GLfixed pd = frustumPlaneDist(plane, p->clip);
+ if (sd >= 0) {
+ if (pd >= 0) {
+ // both inside
+ *output++ = p;
+ oc++;
+ } else {
+ // s inside, p outside (exiting)
+ const GLfixed t = clipDivide(sd, sd-pd);
+ c->arrays.clipVertex(c, buf, t, p, s);
+ *output++ = buf++;
+ oc++;
+ if (++sentinel >= 3)
+ return; // non-convex polygon!
+ }
+ } else {
+ if (pd >= 0) {
+ // s outside (entering)
+ if (pd) {
+ const GLfixed t = clipDivide(pd, pd-sd);
+ c->arrays.clipVertex(c, buf, t, s, p);
+ *output++ = buf++;
+ oc++;
+ if (++sentinel >= 3)
+ return; // non-convex polygon!
+ }
+ *output++ = p;
+ oc++;
+ } else {
+ // both outside
+ }
+ }
+ s = p;
+ sd = pd;
+ }
+ // output list become the new input list
+ if (oc<3)
+ return; // less than 3 vertices left? we're done!
+ ivl = ovl;
+ ic = oc;
+ outi = 1-outi;
+ }
+ cc >>= 1;
+ plane++;
+ } while (cc);
+ }
+
+ // finally we can render our triangles...
+ p0 = ivl[0];
+ p1 = ivl[1];
+ for (unsigned int i=2 ; i<ic ; i++) {
+ p2 = ivl[i];
+ c->lerp.initTriangle(p0, p1, p2);
+ if (cull_triangle(c, p0, p1, p2)) {
+ p1 = p2;
+ continue; // culled!
+ }
+ triangle(c, p0, p1, p2);
+ p1 = p2;
+ }
+}
+
+unsigned int clip_line(ogles_context_t* c, vertex_t* s, vertex_t* p)
+{
+ const uint32_t all_cc = (s->flags | p->flags) & vertex_t::CLIP_ALL;
+
+ if (ggl_unlikely(all_cc & vertex_t::USER_CLIP_ALL))
+ {
+ unsigned int plane = 0;
+ uint32_t cc = (all_cc & vertex_t::USER_CLIP_ALL) >> 8;
+ do {
+ if (cc & 1) {
+ const vec4_t& equation = c->clipPlanes.plane[plane].equation;
+ const GLfixed sd = dot4(equation.v, s->eye.v);
+ const GLfixed pd = dot4(equation.v, p->eye.v);
+ if (sd >= 0) {
+ if (pd >= 0) {
+ // both inside
+ } else {
+ // s inside, p outside (exiting)
+ const GLfixed t = clipDivide(sd, sd-pd);
+ c->arrays.clipEye(c, p, t, p, s);
+ }
+ } else {
+ if (pd >= 0) {
+ // s outside (entering)
+ if (pd) {
+ const GLfixed t = clipDivide(pd, pd-sd);
+ c->arrays.clipEye(c, s, t, s, p);
+ }
+ } else {
+ // both outside
+ return 0;
+ }
+ }
+ }
+ cc >>= 1;
+ plane++;
+ } while (cc);
+ }
+
+ // frustum clip-planes
+ if (all_cc & vertex_t::FRUSTUM_CLIP_ALL)
+ {
+ unsigned int plane = 0;
+ uint32_t cc = all_cc & vertex_t::FRUSTUM_CLIP_ALL;
+ do {
+ if (cc & 1) {
+ const GLfixed sd = frustumPlaneDist(plane, s->clip);
+ const GLfixed pd = frustumPlaneDist(plane, p->clip);
+ if (sd >= 0) {
+ if (pd >= 0) {
+ // both inside
+ } else {
+ // s inside, p outside (exiting)
+ const GLfixed t = clipDivide(sd, sd-pd);
+ c->arrays.clipVertex(c, p, t, p, s);
+ }
+ } else {
+ if (pd >= 0) {
+ // s outside (entering)
+ if (pd) {
+ const GLfixed t = clipDivide(pd, pd-sd);
+ c->arrays.clipVertex(c, s, t, s, p);
+ }
+ } else {
+ // both outside
+ return 0;
+ }
+ }
+ }
+ cc >>= 1;
+ plane++;
+ } while (cc);
+ }
+
+ return 2;
+}
+
+
+}; // namespace android
diff --git a/opengl/libagl/primitives.h b/opengl/libagl/primitives.h
new file mode 100644
index 0000000..1bef604
--- /dev/null
+++ b/opengl/libagl/primitives.h
@@ -0,0 +1,37 @@
+/* libs/opengles/primitives.h
+**
+** Copyright 2006, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+** http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+#ifndef ANDROID_OPENGLES_PRIMITIVES_H
+#define ANDROID_OPENGLES_PRIMITIVES_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include <sys/types.h>
+
+
+namespace android {
+
+namespace gl {
+struct ogles_context_t;
+};
+
+void ogles_validate_primitives(ogles_context_t* c);
+
+}; // namespace android
+
+#endif // ANDROID_OPENGLES_PRIMITIVES_H
+
diff --git a/opengl/libagl/state.cpp b/opengl/libagl/state.cpp
new file mode 100644
index 0000000..5cbabea
--- /dev/null
+++ b/opengl/libagl/state.cpp
@@ -0,0 +1,586 @@
+/* libs/opengles/state.cpp
+**
+** Copyright 2006, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+** http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+#include <stdlib.h>
+
+#include "context.h"
+#include "fp.h"
+#include "state.h"
+#include "array.h"
+#include "matrix.h"
+#include "vertex.h"
+#include "light.h"
+#include "texture.h"
+#include "BufferObjectManager.h"
+#include "TextureObjectManager.h"
+
+namespace android {
+
+// ----------------------------------------------------------------------------
+
+static char const * const gVendorString = "Android";
+static char const * const gRendererString = "Android PixelFlinger 1.0";
+static char const * const gVersionString = "OpenGL ES-CM 1.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_ARB_texture_compression " // OK
+ "GL_ARB_texture_non_power_of_two " // OK
+ "GL_ANDROID_direct_texture " // OK
+ "GL_ANDROID_user_clip_plane " // OK
+ "GL_ANDROID_vertex_buffer_object " // OK
+ "GL_ANDROID_generate_mipmap " // OK
+ ;
+
+// ----------------------------------------------------------------------------
+#if 0
+#pragma mark -
+#endif
+
+ogles_context_t *ogles_init(size_t extra)
+{
+ void* const base = malloc(extra + sizeof(ogles_context_t) + 32);
+ if (!base) return 0;
+
+ ogles_context_t *c =
+ (ogles_context_t *)((ptrdiff_t(base) + extra + 31) & ~0x1FL);
+ memset(c, 0, sizeof(ogles_context_t));
+ ggl_init_context(&(c->rasterizer));
+
+ // XXX: this should be passed as an argument
+ sp<EGLSurfaceManager> smgr(new EGLSurfaceManager());
+ c->surfaceManager = smgr.get();
+ c->surfaceManager->incStrong(c);
+
+ sp<EGLBufferObjectManager> bomgr(new EGLBufferObjectManager());
+ c->bufferObjectManager = bomgr.get();
+ c->bufferObjectManager->incStrong(c);
+
+ ogles_init_array(c);
+ ogles_init_matrix(c);
+ ogles_init_vertex(c);
+ ogles_init_light(c);
+ ogles_init_texture(c);
+
+ c->rasterizer.base = base;
+ c->point.size = TRI_ONE;
+ c->line.width = TRI_ONE;
+
+ // in OpenGL, writing to the depth buffer is enabled by default.
+ c->rasterizer.procs.depthMask(c, 1);
+
+ // OpenGL enables dithering by default
+ c->rasterizer.procs.enable(c, GL_DITHER);
+
+ return c;
+}
+
+void ogles_uninit(ogles_context_t* c)
+{
+ ogles_uninit_array(c);
+ ogles_uninit_matrix(c);
+ ogles_uninit_vertex(c);
+ ogles_uninit_light(c);
+ ogles_uninit_texture(c);
+ c->surfaceManager->decStrong(c);
+ c->bufferObjectManager->decStrong(c);
+ ggl_uninit_context(&(c->rasterizer));
+ free(c->rasterizer.base);
+}
+
+void _ogles_error(ogles_context_t* c, GLenum error)
+{
+ if (c->error == GL_NO_ERROR)
+ c->error = error;
+}
+
+static bool stencilop_valid(GLenum op) {
+ switch (op) {
+ case GL_KEEP:
+ case GL_ZERO:
+ case GL_REPLACE:
+ case GL_INCR:
+ case GL_DECR:
+ case GL_INVERT:
+ return true;
+ }
+ return false;
+}
+
+static void enable_disable(ogles_context_t* c, GLenum cap, int enabled)
+{
+ if ((cap >= GL_LIGHT0) && (cap<GL_LIGHT0+OGLES_MAX_LIGHTS)) {
+ c->lighting.lights[cap-GL_LIGHT0].enable = enabled;
+ c->lighting.enabledLights &= ~(1<<(cap-GL_LIGHT0));
+ c->lighting.enabledLights |= (enabled<<(cap-GL_LIGHT0));
+ return;
+ }
+
+ switch (cap) {
+ case GL_POINT_SMOOTH:
+ c->point.smooth = enabled;
+ break;
+ case GL_LINE_SMOOTH:
+ c->line.smooth = enabled;
+ break;
+ case GL_POLYGON_OFFSET_FILL:
+ c->polygonOffset.enable = enabled;
+ break;
+ case GL_CULL_FACE:
+ c->cull.enable = enabled;
+ break;
+ case GL_LIGHTING:
+ c->lighting.enable = enabled;
+ break;
+ case GL_COLOR_MATERIAL:
+ c->lighting.colorMaterial.enable = enabled;
+ break;
+ case GL_NORMALIZE:
+ case GL_RESCALE_NORMAL:
+ c->transforms.rescaleNormals = enabled ? cap : 0;
+ // XXX: invalidate mvit
+ break;
+
+ case GL_CLIP_PLANE0:
+ case GL_CLIP_PLANE1:
+ case GL_CLIP_PLANE2:
+ case GL_CLIP_PLANE3:
+ case GL_CLIP_PLANE4:
+ case GL_CLIP_PLANE5:
+ c->clipPlanes.enable &= ~(1<<(cap-GL_CLIP_PLANE0));
+ c->clipPlanes.enable |= (enabled<<(cap-GL_CLIP_PLANE0));
+ ogles_invalidate_perspective(c);
+ break;
+
+ case GL_FOG:
+ case GL_DEPTH_TEST:
+ ogles_invalidate_perspective(c);
+ // fall-through...
+ case GL_BLEND:
+ case GL_SCISSOR_TEST:
+ case GL_ALPHA_TEST:
+ case GL_COLOR_LOGIC_OP:
+ case GL_DITHER:
+ case GL_STENCIL_TEST:
+ case GL_TEXTURE_2D:
+ // these need to fall through into the rasterizer
+ c->rasterizer.procs.enableDisable(c, cap, enabled);
+ break;
+
+ case GL_MULTISAMPLE:
+ case GL_SAMPLE_ALPHA_TO_COVERAGE:
+ case GL_SAMPLE_ALPHA_TO_ONE:
+ case GL_SAMPLE_COVERAGE:
+ // not supported in this implementation
+ break;
+
+ default:
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+}
+
+// ----------------------------------------------------------------------------
+}; // namespace android
+// ----------------------------------------------------------------------------
+using namespace android;
+
+#if 0
+#pragma mark -
+#endif
+
+// These ones are super-easy, we're not supporting those features!
+void glSampleCoverage(GLclampf value, GLboolean invert) {
+}
+void glSampleCoveragex(GLclampx value, GLboolean invert) {
+}
+void glStencilFunc(GLenum func, GLint ref, GLuint mask) {
+ ogles_context_t* c = ogles_context_t::get();
+ if (func < GL_NEVER || func > GL_ALWAYS) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ // from OpenGL|ES 1.0 sepcification:
+ // If there is no stencil buffer, no stencil modification can occur
+ // and it is as if the stencil test always passes.
+}
+
+void glStencilOp(GLenum fail, GLenum zfail, GLenum zpass) {
+ ogles_context_t* c = ogles_context_t::get();
+ if ((stencilop_valid(fail) &
+ stencilop_valid(zfail) &
+ stencilop_valid(zpass)) == 0) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+}
+
+// ----------------------------------------------------------------------------
+
+void glAlphaFunc(GLenum func, GLclampf ref)
+{
+ glAlphaFuncx(func, gglFloatToFixed(ref));
+}
+
+void glCullFace(GLenum mode)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ switch (mode) {
+ case GL_FRONT:
+ case GL_BACK:
+ case GL_FRONT_AND_BACK:
+ break;
+ default:
+ ogles_error(c, GL_INVALID_ENUM);
+ }
+ c->cull.cullFace = mode;
+}
+
+void glFrontFace(GLenum mode)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ switch (mode) {
+ case GL_CW:
+ case GL_CCW:
+ break;
+ default:
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ c->cull.frontFace = mode;
+}
+
+void glHint(GLenum target, GLenum mode)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ switch (target) {
+ case GL_FOG_HINT:
+ case GL_GENERATE_MIPMAP_HINT:
+ case GL_LINE_SMOOTH_HINT:
+ break;
+ case GL_POINT_SMOOTH_HINT:
+ c->rasterizer.procs.enableDisable(c,
+ GGL_POINT_SMOOTH_NICE, mode==GL_NICEST);
+ break;
+ case GL_PERSPECTIVE_CORRECTION_HINT:
+ c->perspective = (mode == GL_NICEST) ? 1 : 0;
+ break;
+ default:
+ ogles_error(c, GL_INVALID_ENUM);
+ }
+}
+
+void glEnable(GLenum cap) {
+ ogles_context_t* c = ogles_context_t::get();
+ enable_disable(c, cap, 1);
+}
+void glDisable(GLenum cap) {
+ ogles_context_t* c = ogles_context_t::get();
+ enable_disable(c, cap, 0);
+}
+
+void glFinish()
+{ // nothing to do for our software implementation
+}
+
+void glFlush()
+{ // nothing to do for our software implementation
+}
+
+GLenum glGetError()
+{
+ // From OpenGL|ES 1.0 specification:
+ // If more than one flag has recorded an error, glGetError returns
+ // and clears an arbitrary error flag value. Thus, glGetError should
+ // always be called in a loop, until it returns GL_NO_ERROR,
+ // if all error flags are to be reset.
+
+ ogles_context_t* c = ogles_context_t::get();
+ if (c->error) {
+ const GLenum ret(c->error);
+ c->error = 0;
+ return ret;
+ }
+
+ if (c->rasterizer.error) {
+ const GLenum ret(c->rasterizer.error);
+ c->rasterizer.error = 0;
+ return ret;
+ }
+
+ return GL_NO_ERROR;
+}
+
+const GLubyte* glGetString(GLenum string)
+{
+ switch (string) {
+ 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;
+ }
+ ogles_context_t* c = ogles_context_t::get();
+ ogles_error(c, GL_INVALID_ENUM);
+ return 0;
+}
+
+void glGetIntegerv(GLenum pname, GLint *params)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ switch (pname) {
+ case GL_ALIASED_POINT_SIZE_RANGE:
+ params[0] = 0;
+ params[1] = GGL_MAX_ALIASED_POINT_SIZE;
+ break;
+ case GL_ALIASED_LINE_WIDTH_RANGE:
+ params[0] = 0;
+ params[1] = GGL_MAX_ALIASED_POINT_SIZE;
+ break;
+ case GL_ALPHA_BITS: {
+ int index = c->rasterizer.state.buffers.color.format;
+ GGLFormat const * formats = gglGetPixelFormatTable();
+ params[0] = formats[index].ah - formats[index].al;
+ break;
+ }
+ case GL_RED_BITS: {
+ int index = c->rasterizer.state.buffers.color.format;
+ GGLFormat const * formats = gglGetPixelFormatTable();
+ params[0] = formats[index].rh - formats[index].rl;
+ break;
+ }
+ case GL_GREEN_BITS: {
+ int index = c->rasterizer.state.buffers.color.format;
+ GGLFormat const * formats = gglGetPixelFormatTable();
+ params[0] = formats[index].gh - formats[index].gl;
+ break;
+ }
+ case GL_BLUE_BITS: {
+ int index = c->rasterizer.state.buffers.color.format;
+ GGLFormat const * formats = gglGetPixelFormatTable();
+ params[0] = formats[index].bh - formats[index].bl;
+ break;
+ }
+ case GL_COMPRESSED_TEXTURE_FORMATS:
+ params[ 0] = GL_PALETTE4_RGB8_OES;
+ params[ 1] = GL_PALETTE4_RGBA8_OES;
+ params[ 2] = GL_PALETTE4_R5_G6_B5_OES;
+ params[ 3] = GL_PALETTE4_RGBA4_OES;
+ params[ 4] = GL_PALETTE4_RGB5_A1_OES;
+ params[ 5] = GL_PALETTE8_RGB8_OES;
+ params[ 6] = GL_PALETTE8_RGBA8_OES;
+ params[ 7] = GL_PALETTE8_R5_G6_B5_OES;
+ params[ 8] = GL_PALETTE8_RGBA4_OES;
+ params[ 9] = GL_PALETTE8_RGB5_A1_OES;
+ break;
+ case GL_DEPTH_BITS:
+ params[0] = c->rasterizer.state.buffers.depth.format ? 0 : 16;
+ break;
+ case GL_IMPLEMENTATION_COLOR_READ_FORMAT_OES:
+ params[0] = GL_RGB;
+ break;
+ case GL_IMPLEMENTATION_COLOR_READ_TYPE_OES:
+ params[0] = GL_UNSIGNED_SHORT_5_6_5;
+ break;
+ case GL_MAX_LIGHTS:
+ params[0] = OGLES_MAX_LIGHTS;
+ break;
+ case GL_MAX_CLIP_PLANES:
+ params[0] = OGLES_MAX_CLIP_PLANES;
+ break;
+ case GL_MAX_MODELVIEW_STACK_DEPTH:
+ params[0] = OGLES_MODELVIEW_STACK_DEPTH;
+ break;
+ case GL_MAX_PROJECTION_STACK_DEPTH:
+ params[0] = OGLES_PROJECTION_STACK_DEPTH;
+ break;
+ case GL_MAX_TEXTURE_STACK_DEPTH:
+ params[0] = OGLES_TEXTURE_STACK_DEPTH;
+ break;
+ case GL_MAX_TEXTURE_SIZE:
+ params[0] = GGL_MAX_TEXTURE_SIZE;
+ break;
+ case GL_MAX_TEXTURE_UNITS:
+ params[0] = GGL_TEXTURE_UNIT_COUNT;
+ break;
+ case GL_MAX_VIEWPORT_DIMS:
+ params[0] = GGL_MAX_VIEWPORT_DIMS;
+ params[1] = GGL_MAX_VIEWPORT_DIMS;
+ break;
+ case GL_NUM_COMPRESSED_TEXTURE_FORMATS:
+ params[0] = OGLES_NUM_COMPRESSED_TEXTURE_FORMATS;
+ break;
+ case GL_SMOOTH_LINE_WIDTH_RANGE:
+ params[0] = 0;
+ params[1] = GGL_MAX_SMOOTH_LINE_WIDTH;
+ break;
+ case GL_SMOOTH_POINT_SIZE_RANGE:
+ params[0] = 0;
+ params[1] = GGL_MAX_SMOOTH_POINT_SIZE;
+ break;
+ case GL_STENCIL_BITS:
+ params[0] = 0;
+ break;
+ case GL_SUBPIXEL_BITS:
+ params[0] = GGL_SUBPIXEL_BITS;
+ break;
+
+ case GL_MODELVIEW_MATRIX_FLOAT_AS_INT_BITS_OES:
+ memcpy( params,
+ c->transforms.modelview.top().elements(),
+ 16*sizeof(GLint));
+ break;
+ case GL_PROJECTION_MATRIX_FLOAT_AS_INT_BITS_OES:
+ memcpy( params,
+ c->transforms.projection.top().elements(),
+ 16*sizeof(GLint));
+ break;
+ case GL_TEXTURE_MATRIX_FLOAT_AS_INT_BITS_OES:
+ memcpy( params,
+ c->transforms.texture[c->textures.active].top().elements(),
+ 16*sizeof(GLint));
+ break;
+
+ default:
+ ogles_error(c, GL_INVALID_ENUM);
+ break;
+ }
+}
+
+// ----------------------------------------------------------------------------
+
+void glPointSize(GLfloat size)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if (size <= 0) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ c->point.size = TRI_FROM_FIXED(gglFloatToFixed(size));
+}
+
+void glPointSizex(GLfixed size)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if (size <= 0) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ c->point.size = TRI_FROM_FIXED(size);
+}
+
+// ----------------------------------------------------------------------------
+
+void glLineWidth(GLfloat width)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if (width <= 0) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ c->line.width = TRI_FROM_FIXED(gglFloatToFixed(width));
+}
+
+void glLineWidthx(GLfixed width)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if (width <= 0) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ c->line.width = TRI_FROM_FIXED(width);
+}
+
+// ----------------------------------------------------------------------------
+
+void glColorMask(GLboolean r, GLboolean g, GLboolean b, GLboolean a) {
+ ogles_context_t* c = ogles_context_t::get();
+ c->rasterizer.procs.colorMask(c, r, g, b, a);
+}
+
+void glDepthMask(GLboolean flag) {
+ ogles_context_t* c = ogles_context_t::get();
+ c->rasterizer.procs.depthMask(c, flag);
+}
+
+void glStencilMask(GLuint mask) {
+ ogles_context_t* c = ogles_context_t::get();
+ c->rasterizer.procs.stencilMask(c, mask);
+}
+
+void glDepthFunc(GLenum func) {
+ ogles_context_t* c = ogles_context_t::get();
+ c->rasterizer.procs.depthFunc(c, func);
+}
+
+void glLogicOp(GLenum opcode) {
+ ogles_context_t* c = ogles_context_t::get();
+ c->rasterizer.procs.logicOp(c, opcode);
+}
+
+void glAlphaFuncx(GLenum func, GLclampx ref) {
+ ogles_context_t* c = ogles_context_t::get();
+ c->rasterizer.procs.alphaFuncx(c, func, ref);
+}
+
+void glBlendFunc(GLenum sfactor, GLenum dfactor) {
+ ogles_context_t* c = ogles_context_t::get();
+ c->rasterizer.procs.blendFunc(c, sfactor, dfactor);
+}
+
+void glClear(GLbitfield mask) {
+ ogles_context_t* c = ogles_context_t::get();
+ c->rasterizer.procs.clear(c, mask);
+}
+
+void glClearColorx(GLclampx red, GLclampx green, GLclampx blue, GLclampx alpha) {
+ ogles_context_t* c = ogles_context_t::get();
+ c->rasterizer.procs.clearColorx(c, red, green, blue, alpha);
+}
+
+void glClearColor(GLclampf r, GLclampf g, GLclampf b, GLclampf a)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ c->rasterizer.procs.clearColorx(c,
+ gglFloatToFixed(r),
+ gglFloatToFixed(g),
+ gglFloatToFixed(b),
+ gglFloatToFixed(a));
+}
+
+void glClearDepthx(GLclampx depth) {
+ ogles_context_t* c = ogles_context_t::get();
+ c->rasterizer.procs.clearDepthx(c, depth);
+}
+
+void glClearDepthf(GLclampf depth)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ c->rasterizer.procs.clearDepthx(c, gglFloatToFixed(depth));
+}
+
+void glClearStencil(GLint s) {
+ ogles_context_t* c = ogles_context_t::get();
+ c->rasterizer.procs.clearStencil(c, s);
+}
diff --git a/opengl/libagl/state.h b/opengl/libagl/state.h
new file mode 100644
index 0000000..55a5ccb
--- /dev/null
+++ b/opengl/libagl/state.h
@@ -0,0 +1,54 @@
+/* libs/opengles/state.h
+**
+** Copyright 2006, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+** http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+#ifndef ANDROID_OPENGLES_STATE_H
+#define ANDROID_OPENGLES_STATE_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include <sys/types.h>
+
+#include <private/pixelflinger/ggl_context.h>
+
+#include <GLES/gl.h>
+
+#include <stdio.h>
+
+namespace android {
+
+ogles_context_t *ogles_init(size_t extra);
+void ogles_uninit(ogles_context_t* c);
+void _ogles_error(ogles_context_t* c, GLenum error);
+
+#ifndef TRACE_GL_ERRORS
+#define TRACE_GL_ERRORS 0
+#endif
+
+#if TRACE_GL_ERRORS
+#define ogles_error(c, error) \
+do { \
+ printf("ogles_error at file %s line %d\n", __FILE__, __LINE__); \
+ _ogles_error(c, error); \
+} while (0)
+#else /* !TRACE_GL_ERRORS */
+#define ogles_error(c, error) _ogles_error((c), (error))
+#endif
+
+}; // namespace android
+
+#endif // ANDROID_OPENGLES_STATE_H
+
diff --git a/opengl/libagl/texture.cpp b/opengl/libagl/texture.cpp
new file mode 100644
index 0000000..b6f534b
--- /dev/null
+++ b/opengl/libagl/texture.cpp
@@ -0,0 +1,1421 @@
+/* libs/opengles/texture.cpp
+**
+** Copyright 2006, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+** http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "context.h"
+#include "fp.h"
+#include "state.h"
+#include "texture.h"
+#include "TextureObjectManager.h"
+
+namespace android {
+
+// ----------------------------------------------------------------------------
+
+static void bindTextureTmu(
+ ogles_context_t* c, int tmu, GLuint texture, const sp<EGLTextureObject>& tex);
+
+static __attribute__((noinline))
+void generateMipmap(ogles_context_t* c, GLint level);
+
+// ----------------------------------------------------------------------------
+
+#if 0
+#pragma mark -
+#pragma mark Init
+#endif
+
+void ogles_init_texture(ogles_context_t* c)
+{
+ c->textures.packAlignment = 4;
+ c->textures.unpackAlignment = 4;
+
+ // each context has a default named (0) texture (not shared)
+ c->textures.defaultTexture = new EGLTextureObject();
+ c->textures.defaultTexture->incStrong(c);
+
+ // bind the default texture to each texture unit
+ for (int i=0; i<GGL_TEXTURE_UNIT_COUNT ; i++) {
+ bindTextureTmu(c, i, 0, c->textures.defaultTexture);
+ memset(c->current.texture[i].v, 0, sizeof(vec4_t));
+ c->current.texture[i].Q = 0x10000;
+ }
+}
+
+void ogles_uninit_texture(ogles_context_t* c)
+{
+ if (c->textures.ggl)
+ gglUninit(c->textures.ggl);
+ c->textures.defaultTexture->decStrong(c);
+ for (int i=0; i<GGL_TEXTURE_UNIT_COUNT ; i++) {
+ if (c->textures.tmu[i].texture)
+ c->textures.tmu[i].texture->decStrong(c);
+ }
+}
+
+static __attribute__((noinline))
+void validate_tmu(ogles_context_t* c, int i)
+{
+ texture_unit_t& u(c->textures.tmu[i]);
+ if (u.dirty) {
+ u.dirty = 0;
+ c->rasterizer.procs.activeTexture(c, i);
+ c->rasterizer.procs.bindTexture(c, &(u.texture->surface));
+ c->rasterizer.procs.texGeni(c, GGL_S,
+ GGL_TEXTURE_GEN_MODE, GGL_AUTOMATIC);
+ c->rasterizer.procs.texGeni(c, GGL_T,
+ GGL_TEXTURE_GEN_MODE, GGL_AUTOMATIC);
+ c->rasterizer.procs.texParameteri(c, GGL_TEXTURE_2D,
+ GGL_TEXTURE_WRAP_S, u.texture->wraps);
+ c->rasterizer.procs.texParameteri(c, GGL_TEXTURE_2D,
+ GGL_TEXTURE_WRAP_T, u.texture->wrapt);
+ c->rasterizer.procs.texParameteri(c, GGL_TEXTURE_2D,
+ GGL_TEXTURE_MIN_FILTER, u.texture->min_filter);
+ c->rasterizer.procs.texParameteri(c, GGL_TEXTURE_2D,
+ GGL_TEXTURE_MAG_FILTER, u.texture->mag_filter);
+
+ // disable this texture unit if it's not complete
+ if (!u.texture->isComplete()) {
+ c->rasterizer.procs.disable(c, GGL_TEXTURE_2D);
+ }
+ }
+}
+
+void ogles_validate_texture_impl(ogles_context_t* c)
+{
+ for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; i++) {
+ if (c->rasterizer.state.texture[i].enable)
+ validate_tmu(c, i);
+ }
+ c->rasterizer.procs.activeTexture(c, c->textures.active);
+}
+
+static
+void invalidate_texture(ogles_context_t* c, int tmu, uint8_t flags = 0xFF) {
+ c->textures.tmu[tmu].dirty = flags;
+}
+
+// ----------------------------------------------------------------------------
+#if 0
+#pragma mark -
+#pragma mark Format conversion
+#endif
+
+static uint32_t gl2format_table[6][4] = {
+ // BYTE, 565, 4444, 5551
+ { GGL_PIXEL_FORMAT_A_8,
+ 0, 0, 0 }, // GL_ALPHA
+ { GGL_PIXEL_FORMAT_RGB_888,
+ GGL_PIXEL_FORMAT_RGB_565,
+ 0, 0 }, // GL_RGB
+ { GGL_PIXEL_FORMAT_RGBA_8888,
+ 0,
+ GGL_PIXEL_FORMAT_RGBA_4444,
+ GGL_PIXEL_FORMAT_RGBA_5551 }, // GL_RGBA
+ { GGL_PIXEL_FORMAT_L_8,
+ 0, 0, 0 }, // GL_LUMINANCE
+ { GGL_PIXEL_FORMAT_LA_88,
+ 0, 0, 0 }, // GL_LUMINANCE_ALPHA
+};
+
+static int32_t convertGLPixelFormat(GLint format, GLenum type)
+{
+ int32_t fi = -1;
+ int32_t ti = -1;
+ switch (format) {
+ case GL_ALPHA: fi = 0; break;
+ case GL_RGB: fi = 1; break;
+ case GL_RGBA: fi = 2; break;
+ case GL_LUMINANCE: fi = 3; break;
+ case GL_LUMINANCE_ALPHA: fi = 4; break;
+ }
+ switch (type) {
+ case GL_UNSIGNED_BYTE: ti = 0; break;
+ case GL_UNSIGNED_SHORT_5_6_5: ti = 1; break;
+ case GL_UNSIGNED_SHORT_4_4_4_4: ti = 2; break;
+ case GL_UNSIGNED_SHORT_5_5_5_1: ti = 3; break;
+ }
+ if (fi==-1 || ti==-1)
+ return 0;
+ return gl2format_table[fi][ti];
+}
+
+// ----------------------------------------------------------------------------
+
+static GLenum validFormatType(ogles_context_t* c, GLenum format, GLenum type)
+{
+ GLenum error = 0;
+ if (format<GL_ALPHA || format>GL_LUMINANCE_ALPHA) {
+ error = GL_INVALID_ENUM;
+ }
+ if (type != GL_UNSIGNED_BYTE && type != GL_UNSIGNED_SHORT_4_4_4_4 &&
+ type != GL_UNSIGNED_SHORT_5_5_5_1 && type != GL_UNSIGNED_SHORT_5_6_5) {
+ error = GL_INVALID_ENUM;
+ }
+ if (type == GL_UNSIGNED_SHORT_5_6_5 && format != GL_RGB) {
+ error = GL_INVALID_OPERATION;
+ }
+ if ((type == GL_UNSIGNED_SHORT_4_4_4_4 ||
+ type == GL_UNSIGNED_SHORT_5_5_5_1) && format != GL_RGBA) {
+ error = GL_INVALID_OPERATION;
+ }
+ if (error) {
+ ogles_error(c, error);
+ }
+ return error;
+}
+
+// ----------------------------------------------------------------------------
+
+GGLContext* getRasterizer(ogles_context_t* c)
+{
+ GGLContext* ggl = c->textures.ggl;
+ if (ggl_unlikely(!ggl)) {
+ // this is quite heavy the first time...
+ gglInit(&ggl);
+ if (!ggl) {
+ return 0;
+ }
+ GGLfixed colors[4] = { 0, 0, 0, 0x10000 };
+ c->textures.ggl = ggl;
+ ggl->activeTexture(ggl, 0);
+ ggl->enable(ggl, GGL_TEXTURE_2D);
+ ggl->texEnvi(ggl, GGL_TEXTURE_ENV, GGL_TEXTURE_ENV_MODE, GGL_REPLACE);
+ ggl->disable(ggl, GGL_DITHER);
+ ggl->shadeModel(ggl, GGL_FLAT);
+ ggl->color4xv(ggl, colors);
+ }
+ return ggl;
+}
+
+static __attribute__((noinline))
+int copyPixels(
+ ogles_context_t* c,
+ const GGLSurface& dst,
+ GLint xoffset, GLint yoffset,
+ const GGLSurface& src,
+ GLint x, GLint y, GLsizei w, GLsizei h)
+{
+ if ((dst.format == src.format) &&
+ (dst.stride == src.stride) &&
+ (dst.width == src.width) &&
+ (dst.height == src.height) &&
+ (dst.stride > 0) &&
+ ((x|y) == 0) &&
+ ((xoffset|yoffset) == 0))
+ {
+ // this is a common case...
+ const GGLFormat& pixelFormat(c->rasterizer.formats[src.format]);
+ const size_t size = src.height * src.stride * pixelFormat.size;
+ memcpy(dst.data, src.data, size);
+ return 0;
+ }
+
+ // use pixel-flinger to handle all the conversions
+ GGLContext* ggl = getRasterizer(c);
+ if (!ggl) {
+ // the only reason this would fail is because we ran out of memory
+ return GL_OUT_OF_MEMORY;
+ }
+
+ ggl->colorBuffer(ggl, &dst);
+ ggl->bindTexture(ggl, &src);
+ ggl->texCoord2i(ggl, x-xoffset, y-yoffset);
+ ggl->recti(ggl, xoffset, yoffset, xoffset+w, yoffset+h);
+ return 0;
+}
+
+// ----------------------------------------------------------------------------
+
+static __attribute__((noinline))
+sp<EGLTextureObject> getAndBindActiveTextureObject(ogles_context_t* c)
+{
+ sp<EGLTextureObject> tex;
+ const int active = c->textures.active;
+ const GLuint name = c->textures.tmu[active].name;
+
+ // free the reference to the previously bound object
+ texture_unit_t& u(c->textures.tmu[active]);
+ if (u.texture)
+ u.texture->decStrong(c);
+
+ if (name == 0) {
+ // 0 is our local texture object, not shared with anyone.
+ // But it affects all bound TMUs immediately.
+ // (we need to invalidate all units bound to this texture object)
+ tex = c->textures.defaultTexture;
+ for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; i++) {
+ if (c->textures.tmu[i].texture == tex.get())
+ invalidate_texture(c, i);
+ }
+ } else {
+ // get a new texture object for that name
+ tex = c->surfaceManager->replaceTexture(name);
+ }
+
+ // bind this texture to the current active texture unit
+ // and add a reference to this texture object
+ u.texture = tex.get();
+ u.texture->incStrong(c);
+ u.name = name;
+ invalidate_texture(c, active);
+ return tex;
+}
+
+void bindTextureTmu(
+ ogles_context_t* c, int tmu, GLuint texture, const sp<EGLTextureObject>& tex)
+{
+ if (tex.get() == c->textures.tmu[tmu].texture)
+ return;
+
+ // free the reference to the previously bound object
+ texture_unit_t& u(c->textures.tmu[tmu]);
+ if (u.texture)
+ u.texture->decStrong(c);
+
+ // bind this texture to the current active texture unit
+ // and add a reference to this texture object
+ u.texture = tex.get();
+ u.texture->incStrong(c);
+ u.name = texture;
+ invalidate_texture(c, tmu);
+}
+
+int createTextureSurface(ogles_context_t* c,
+ GGLSurface** outSurface, int32_t* outSize, GLint level,
+ GLenum format, GLenum type, GLsizei width, GLsizei height,
+ GLenum compressedFormat = 0)
+{
+ // find out which texture is bound to the current unit
+ const int active = c->textures.active;
+ const GLuint name = c->textures.tmu[active].name;
+
+ // convert the pixelformat to one we can handle
+ const int32_t formatIdx = convertGLPixelFormat(format, type);
+ if (formatIdx == 0) { // we don't know what to do with this
+ return GL_INVALID_OPERATION;
+ }
+
+ // figure out the size we need as well as the stride
+ const GGLFormat& pixelFormat(c->rasterizer.formats[formatIdx]);
+ const int32_t align = c->textures.unpackAlignment-1;
+ const int32_t bpr = ((width * pixelFormat.size) + align) & ~align;
+ const size_t size = bpr * height;
+ const int32_t stride = bpr / pixelFormat.size;
+
+ if (level > 0) {
+ const int active = c->textures.active;
+ EGLTextureObject* tex = c->textures.tmu[active].texture;
+ status_t err = tex->reallocate(level,
+ width, height, stride, formatIdx, compressedFormat, bpr);
+ if (err != NO_ERROR)
+ return GL_OUT_OF_MEMORY;
+ GGLSurface& surface = tex->editMip(level);
+ *outSurface = &surface;
+ *outSize = size;
+ return 0;
+ }
+
+ sp<EGLTextureObject> tex = getAndBindActiveTextureObject(c);
+ status_t err = tex->reallocate(level,
+ width, height, stride, formatIdx, compressedFormat, bpr);
+ if (err != NO_ERROR)
+ return GL_OUT_OF_MEMORY;
+
+ tex->internalformat = format;
+ *outSurface = &tex->surface;
+ *outSize = size;
+ return 0;
+}
+
+static void decodePalette4(const GLvoid *data, int level, int width, int height,
+ void *surface, int stride, int format)
+
+{
+ int indexBits = 8;
+ int entrySize = 0;
+ switch (format) {
+ case GL_PALETTE4_RGB8_OES:
+ indexBits = 4;
+ /* FALLTHROUGH */
+ case GL_PALETTE8_RGB8_OES:
+ entrySize = 3;
+ break;
+
+ case GL_PALETTE4_RGBA8_OES:
+ indexBits = 4;
+ /* FALLTHROUGH */
+ case GL_PALETTE8_RGBA8_OES:
+ entrySize = 4;
+ break;
+
+ case GL_PALETTE4_R5_G6_B5_OES:
+ case GL_PALETTE4_RGBA4_OES:
+ case GL_PALETTE4_RGB5_A1_OES:
+ indexBits = 4;
+ /* FALLTHROUGH */
+ case GL_PALETTE8_R5_G6_B5_OES:
+ case GL_PALETTE8_RGBA4_OES:
+ case GL_PALETTE8_RGB5_A1_OES:
+ entrySize = 2;
+ break;
+ }
+
+ const int paletteSize = (1 << indexBits) * entrySize;
+ uint8_t const* pixels = (uint8_t *)data + paletteSize;
+ for (int i=0 ; i<level ; i++) {
+ int w = (width >> i) ? : 1;
+ int h = (height >> i) ? : 1;
+ pixels += h * ((w * indexBits) / 8);
+ }
+ width = (width >> level) ? : 1;
+ height = (height >> level) ? : 1;
+
+ if (entrySize == 2) {
+ uint8_t const* const palette = (uint8_t*)data;
+ for (int y=0 ; y<height ; y++) {
+ uint8_t* p = (uint8_t*)surface + y*stride*2;
+ if (indexBits == 8) {
+ for (int x=0 ; x<width ; x++) {
+ int index = 2 * (*pixels++);
+ *p++ = palette[index + 0];
+ *p++ = palette[index + 1];
+ }
+ } else {
+ for (int x=0 ; x<width ; x+=2) {
+ int v = *pixels++;
+ int index = 2 * (v >> 4);
+ *p++ = palette[index + 0];
+ *p++ = palette[index + 1];
+ if (x+1 < width) {
+ index = 2 * (v & 0xF);
+ *p++ = palette[index + 0];
+ *p++ = palette[index + 1];
+ }
+ }
+ }
+ }
+ } else if (entrySize == 3) {
+ uint8_t const* const palette = (uint8_t*)data;
+ for (int y=0 ; y<height ; y++) {
+ uint8_t* p = (uint8_t*)surface + y*stride*3;
+ if (indexBits == 8) {
+ for (int x=0 ; x<width ; x++) {
+ int index = 3 * (*pixels++);
+ *p++ = palette[index + 0];
+ *p++ = palette[index + 1];
+ *p++ = palette[index + 2];
+ }
+ } else {
+ for (int x=0 ; x<width ; x+=2) {
+ int v = *pixels++;
+ int index = 3 * (v >> 4);
+ *p++ = palette[index + 0];
+ *p++ = palette[index + 1];
+ *p++ = palette[index + 2];
+ if (x+1 < width) {
+ index = 3 * (v & 0xF);
+ *p++ = palette[index + 0];
+ *p++ = palette[index + 1];
+ *p++ = palette[index + 2];
+ }
+ }
+ }
+ }
+ } else if (entrySize == 4) {
+ uint8_t const* const palette = (uint8_t*)data;
+ for (int y=0 ; y<height ; y++) {
+ uint8_t* p = (uint8_t*)surface + y*stride*4;
+ if (indexBits == 8) {
+ for (int x=0 ; x<width ; x++) {
+ int index = 4 * (*pixels++);
+ *p++ = palette[index + 0];
+ *p++ = palette[index + 1];
+ *p++ = palette[index + 2];
+ *p++ = palette[index + 3];
+ }
+ } else {
+ for (int x=0 ; x<width ; x+=2) {
+ int v = *pixels++;
+ int index = 4 * (v >> 4);
+ *p++ = palette[index + 0];
+ *p++ = palette[index + 1];
+ *p++ = palette[index + 2];
+ *p++ = palette[index + 3];
+ if (x+1 < width) {
+ index = 4 * (v & 0xF);
+ *p++ = palette[index + 0];
+ *p++ = palette[index + 1];
+ *p++ = palette[index + 2];
+ *p++ = palette[index + 3];
+ }
+ }
+ }
+ }
+ }
+}
+
+
+
+static __attribute__((noinline))
+void set_depth_and_fog(ogles_context_t* c, GLint z)
+{
+ const uint32_t enables = c->rasterizer.state.enables;
+ // we need to compute Zw
+ int32_t iterators[3];
+ iterators[1] = iterators[2] = 0;
+ GGLfixed Zw;
+ GGLfixed n = gglFloatToFixed(c->transforms.vpt.zNear);
+ GGLfixed f = gglFloatToFixed(c->transforms.vpt.zFar);
+ if (z<=0) Zw = n;
+ else if (z>=1) Zw = f;
+ else Zw = gglMulAddx(z, (f-n), n);
+ if (enables & GGL_ENABLE_FOG) {
+ // set up fog if needed...
+ iterators[0] = c->fog.fog(c, Zw);
+ c->rasterizer.procs.fogGrad3xv(c, iterators);
+ }
+ if (enables & GGL_ENABLE_DEPTH_TEST) {
+ // set up z-test if needed...
+ int32_t z = (Zw & ~(Zw>>31));
+ if (z >= 0x10000)
+ z = 0xFFFF;
+ iterators[0] = (z << 16) | z;
+ c->rasterizer.procs.zGrad3xv(c, iterators);
+ }
+}
+
+// ----------------------------------------------------------------------------
+#if 0
+#pragma mark -
+#pragma mark Generate mimaps
+#endif
+
+extern status_t buildAPyramid(ogles_context_t* c, EGLTextureObject* tex);
+
+void generateMipmap(ogles_context_t* c, GLint level)
+{
+ if (level == 0) {
+ const int active = c->textures.active;
+ EGLTextureObject* tex = c->textures.tmu[active].texture;
+ if (tex->generate_mipmap) {
+ if (buildAPyramid(c, tex) != NO_ERROR) {
+ ogles_error(c, GL_OUT_OF_MEMORY);
+ return;
+ }
+ }
+ }
+}
+
+
+static void texParameterx(
+ GLenum target, GLenum pname, GLfixed param, ogles_context_t* c)
+{
+ if (target != GL_TEXTURE_2D) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+
+ EGLTextureObject* textureObject = c->textures.tmu[c->textures.active].texture;
+ switch (pname) {
+ case GL_TEXTURE_WRAP_S:
+ if ((param == GL_REPEAT) ||
+ (param == GL_CLAMP_TO_EDGE)) {
+ textureObject->wraps = param;
+ } else {
+ goto invalid_enum;
+ }
+ break;
+ case GL_TEXTURE_WRAP_T:
+ if ((param == GL_REPEAT) ||
+ (param == GL_CLAMP_TO_EDGE)) {
+ textureObject->wrapt = param;
+ } else {
+ goto invalid_enum;
+ }
+ break;
+ case GL_TEXTURE_MIN_FILTER:
+ if ((param == GL_NEAREST) ||
+ (param == GL_LINEAR) ||
+ (param == GL_NEAREST_MIPMAP_NEAREST) ||
+ (param == GL_LINEAR_MIPMAP_NEAREST) ||
+ (param == GL_NEAREST_MIPMAP_LINEAR) ||
+ (param == GL_LINEAR_MIPMAP_LINEAR)) {
+ textureObject->min_filter = param;
+ } else {
+ goto invalid_enum;
+ }
+ break;
+ case GL_TEXTURE_MAG_FILTER:
+ if ((param == GL_NEAREST) ||
+ (param == GL_LINEAR)) {
+ textureObject->mag_filter = param;
+ } else {
+ goto invalid_enum;
+ }
+ break;
+ case GL_GENERATE_MIPMAP:
+ textureObject->generate_mipmap = param;
+ break;
+ default:
+invalid_enum:
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ invalidate_texture(c, c->textures.active);
+}
+
+
+static void drawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed w, GLfixed h,
+ ogles_context_t* c)
+{
+ // quickly reject empty rects
+ if ((w|h) <= 0)
+ return;
+
+ const GGLSurface& cbSurface = c->rasterizer.state.buffers.color.s;
+ y = gglIntToFixed(cbSurface.height) - (y + h);
+ w >>= FIXED_BITS;
+ h >>= FIXED_BITS;
+
+ // set up all texture units
+ for (int i=0 ; i<GGL_TEXTURE_UNIT_COUNT ; i++) {
+ if (!c->rasterizer.state.texture[i].enable)
+ continue;
+
+ int32_t texcoords[8];
+ texture_unit_t& u(c->textures.tmu[i]);
+
+ // validate this tmu (bind, wrap, filter)
+ validate_tmu(c, i);
+ // we CLAMP here, which works with premultiplied (s,t)
+ c->rasterizer.procs.texParameteri(c,
+ GGL_TEXTURE_2D, GGL_TEXTURE_WRAP_S, GGL_CLAMP);
+ c->rasterizer.procs.texParameteri(c,
+ GGL_TEXTURE_2D, GGL_TEXTURE_WRAP_T, GGL_CLAMP);
+ u.dirty = 0xFF; // XXX: should be more subtle
+
+ EGLTextureObject* textureObject = u.texture;
+ const GLint Ucr = textureObject->crop_rect[0] << 16;
+ const GLint Vcr = textureObject->crop_rect[1] << 16;
+ const GLint Wcr = textureObject->crop_rect[2] << 16;
+ const GLint Hcr = textureObject->crop_rect[3] << 16;
+
+ // computes texture coordinates (pre-multiplied)
+ int32_t dsdx = Wcr / w; // dsdx = ((Wcr/w)/Wt)*Wt
+ int32_t dtdy =-Hcr / h; // dtdy = -((Hcr/h)/Ht)*Ht
+ int32_t s0 = Ucr - gglMulx(dsdx, x); // s0 = Ucr - x * dsdx
+ int32_t t0 = (Vcr+Hcr) - gglMulx(dtdy, y); // t0 = (Vcr+Hcr) - y*dtdy
+ texcoords[0] = s0;
+ texcoords[1] = dsdx;
+ texcoords[2] = 0;
+ texcoords[3] = t0;
+ texcoords[4] = 0;
+ texcoords[5] = dtdy;
+ texcoords[6] = 0;
+ texcoords[7] = 0;
+ c->rasterizer.procs.texCoordGradScale8xv(c, i, texcoords);
+ }
+
+ const uint32_t enables = c->rasterizer.state.enables;
+ if (ggl_unlikely(enables & (GGL_ENABLE_DEPTH_TEST|GGL_ENABLE_FOG)))
+ set_depth_and_fog(c, z);
+
+ c->rasterizer.procs.activeTexture(c, c->textures.active);
+ c->rasterizer.procs.color4xv(c, c->currentColorClamped.v);
+ c->rasterizer.procs.disable(c, GGL_W_LERP);
+ c->rasterizer.procs.disable(c, GGL_AA);
+ c->rasterizer.procs.shadeModel(c, GL_FLAT);
+ c->rasterizer.procs.recti(c,
+ gglFixedToIntRound(x),
+ gglFixedToIntRound(y),
+ gglFixedToIntRound(x)+w,
+ gglFixedToIntRound(y)+h);
+}
+
+static void drawTexiOES(GLint x, GLint y, GLint z, GLint w, GLint h, ogles_context_t* c)
+{
+ // All coordinates are integer, so if we have only one
+ // texture unit active and no scaling is required
+ // THEN, we can use our special 1:1 mapping
+ // which is a lot faster.
+
+ if (ggl_likely(c->rasterizer.state.enabled_tmu == 1)) {
+ const int tmu = 0;
+ texture_unit_t& u(c->textures.tmu[tmu]);
+ EGLTextureObject* textureObject = u.texture;
+ const GLint Wcr = textureObject->crop_rect[2];
+ const GLint Hcr = textureObject->crop_rect[3];
+
+ if ((w == Wcr) && (h == -Hcr)) {
+ if ((w|h) <= 0) return; // quickly reject empty rects
+
+ if (u.dirty) {
+ c->rasterizer.procs.activeTexture(c, tmu);
+ c->rasterizer.procs.bindTexture(c, &(u.texture->surface));
+ c->rasterizer.procs.texParameteri(c, GGL_TEXTURE_2D,
+ GGL_TEXTURE_MIN_FILTER, u.texture->min_filter);
+ c->rasterizer.procs.texParameteri(c, GGL_TEXTURE_2D,
+ GGL_TEXTURE_MAG_FILTER, u.texture->mag_filter);
+ }
+ c->rasterizer.procs.texGeni(c, GGL_S,
+ GGL_TEXTURE_GEN_MODE, GGL_ONE_TO_ONE);
+ c->rasterizer.procs.texGeni(c, GGL_T,
+ GGL_TEXTURE_GEN_MODE, GGL_ONE_TO_ONE);
+ u.dirty = 0xFF; // XXX: should be more subtle
+ c->rasterizer.procs.activeTexture(c, c->textures.active);
+
+ const GGLSurface& cbSurface = c->rasterizer.state.buffers.color.s;
+ y = cbSurface.height - (y + h);
+ const GLint Ucr = textureObject->crop_rect[0];
+ const GLint Vcr = textureObject->crop_rect[1];
+ const GLint s0 = Ucr - x;
+ const GLint t0 = (Vcr + Hcr) - y;
+
+ const GLuint tw = textureObject->surface.width;
+ const GLuint th = textureObject->surface.height;
+ if ((uint32_t(s0+x+w) > tw) || (uint32_t(t0+y+h) > th)) {
+ // The GL spec is unclear about what should happen
+ // in this case, so we just use the slow case, which
+ // at least won't crash
+ goto slow_case;
+ }
+
+ c->rasterizer.procs.texCoord2i(c, s0, t0);
+ const uint32_t enables = c->rasterizer.state.enables;
+ if (ggl_unlikely(enables & (GGL_ENABLE_DEPTH_TEST|GGL_ENABLE_FOG)))
+ set_depth_and_fog(c, z);
+
+ c->rasterizer.procs.color4xv(c, c->currentColorClamped.v);
+ c->rasterizer.procs.disable(c, GGL_W_LERP);
+ c->rasterizer.procs.disable(c, GGL_AA);
+ c->rasterizer.procs.shadeModel(c, GL_FLAT);
+ c->rasterizer.procs.recti(c, x, y, x+w, y+h);
+ return;
+ }
+ }
+
+slow_case:
+ drawTexxOES(
+ gglIntToFixed(x), gglIntToFixed(y), gglIntToFixed(z),
+ gglIntToFixed(w), gglIntToFixed(h),
+ c);
+}
+
+
+}; // namespace android
+// ----------------------------------------------------------------------------
+
+using namespace android;
+
+
+#if 0
+#pragma mark -
+#pragma mark Texture API
+#endif
+
+void glActiveTexture(GLenum texture)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if (uint32_t(texture-GL_TEXTURE0) > uint32_t(GGL_TEXTURE_UNIT_COUNT)) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ c->textures.active = texture - GL_TEXTURE0;
+ c->rasterizer.procs.activeTexture(c, c->textures.active);
+}
+
+void glBindTexture(GLenum target, GLuint texture)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if (target != GL_TEXTURE_2D) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+
+ // Bind or create a texture
+ sp<EGLTextureObject> tex;
+ if (texture == 0) {
+ // 0 is our local texture object
+ tex = c->textures.defaultTexture;
+ } else {
+ tex = c->surfaceManager->texture(texture);
+ if (ggl_unlikely(tex == 0)) {
+ tex = c->surfaceManager->createTexture(texture);
+ if (tex == 0) {
+ ogles_error(c, GL_OUT_OF_MEMORY);
+ return;
+ }
+ }
+ }
+ bindTextureTmu(c, c->textures.active, texture, tex);
+}
+
+void glGenTextures(GLsizei n, GLuint *textures)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if (n<0) {
+ ogles_error(c, GL_INVALID_VALUE);
+ return;
+ }
+ // generate unique (shared) texture names
+ c->surfaceManager->getToken(n, textures);
+}
+
+void glDeleteTextures(GLsizei n, const GLuint *textures)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if (n<0) {
+ ogles_error(c, GL_INVALID_VALUE);
+ return;
+ }
+
+ // If deleting a bound texture, bind this unit to 0
+ for (int t=0 ; t<GGL_TEXTURE_UNIT_COUNT ; t++) {
+ if (c->textures.tmu[t].name == 0)
+ continue;
+ for (int i=0 ; i<n ; i++) {
+ if (textures[i] && (textures[i] == c->textures.tmu[t].name)) {
+ // bind this tmu to texture 0
+ sp<EGLTextureObject> tex(c->textures.defaultTexture);
+ bindTextureTmu(c, t, 0, tex);
+ }
+ }
+ }
+ c->surfaceManager->deleteTextures(n, textures);
+ c->surfaceManager->recycleTokens(n, textures);
+}
+
+void glMultiTexCoord4f(
+ GLenum target, GLfloat s, GLfloat t, GLfloat r, GLfloat q)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if (uint32_t(target-GL_TEXTURE0) > uint32_t(GGL_TEXTURE_UNIT_COUNT)) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ const int tmu = target-GL_TEXTURE0;
+ c->current.texture[tmu].S = gglFloatToFixed(s);
+ c->current.texture[tmu].T = gglFloatToFixed(t);
+ c->current.texture[tmu].R = gglFloatToFixed(r);
+ c->current.texture[tmu].Q = gglFloatToFixed(q);
+}
+
+void glMultiTexCoord4x(
+ GLenum target, GLfixed s, GLfixed t, GLfixed r, GLfixed q)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if (uint32_t(target-GL_TEXTURE0) > uint32_t(GGL_TEXTURE_UNIT_COUNT)) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ const int tmu = target-GL_TEXTURE0;
+ c->current.texture[tmu].S = s;
+ c->current.texture[tmu].T = t;
+ c->current.texture[tmu].R = r;
+ c->current.texture[tmu].Q = q;
+}
+
+void glPixelStorei(GLenum pname, GLint param)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if ((pname != GL_PACK_ALIGNMENT) && (pname != GL_UNPACK_ALIGNMENT)) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ if ((param<=0 || param>8) || (param & (param-1))) {
+ ogles_error(c, GL_INVALID_VALUE);
+ return;
+ }
+ if (pname == GL_PACK_ALIGNMENT)
+ c->textures.packAlignment = param;
+ if (pname == GL_UNPACK_ALIGNMENT)
+ c->textures.unpackAlignment = param;
+}
+
+void glTexEnvf(GLenum target, GLenum pname, GLfloat param)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ c->rasterizer.procs.texEnvi(c, target, pname, GLint(param));
+}
+
+void glTexEnvfv(
+ GLenum target, GLenum pname, const GLfloat *params)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if (pname == GL_TEXTURE_ENV_MODE) {
+ c->rasterizer.procs.texEnvi(c, target, pname, GLint(*params));
+ return;
+ }
+ if (pname == GL_TEXTURE_ENV_COLOR) {
+ GGLfixed fixed[4];
+ for (int i=0 ; i<4 ; i++)
+ fixed[i] = gglFloatToFixed(params[i]);
+ c->rasterizer.procs.texEnvxv(c, target, pname, fixed);
+ return;
+ }
+ ogles_error(c, GL_INVALID_ENUM);
+}
+
+void glTexEnvx(GLenum target, GLenum pname, GLfixed param)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ c->rasterizer.procs.texEnvi(c, target, pname, param);
+}
+
+void glTexEnvxv(
+ GLenum target, GLenum pname, const GLfixed *params)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ c->rasterizer.procs.texEnvxv(c, target, pname, params);
+}
+
+void glTexParameteriv(
+ GLenum target, GLenum pname, const GLint* params)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if (target != GGL_TEXTURE_2D) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+
+ EGLTextureObject* textureObject = c->textures.tmu[c->textures.active].texture;
+ switch (pname) {
+ case GL_TEXTURE_CROP_RECT_OES:
+ memcpy(textureObject->crop_rect, params, 4*sizeof(GLint));
+ break;
+ default:
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+}
+
+void glTexParameterf(
+ GLenum target, GLenum pname, GLfloat param)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ texParameterx(target, pname, GLfixed(param), c);
+}
+
+void glTexParameterx(
+ GLenum target, GLenum pname, GLfixed param)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ texParameterx(target, pname, param, c);
+}
+
+// ----------------------------------------------------------------------------
+#if 0
+#pragma mark -
+#endif
+
+void glCompressedTexImage2D(
+ GLenum target, GLint level, GLenum internalformat,
+ GLsizei width, GLsizei height, GLint border,
+ GLsizei imageSize, const GLvoid *data)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if (target != GL_TEXTURE_2D) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ if ((internalformat < GL_PALETTE4_RGB8_OES ||
+ internalformat > GL_PALETTE8_RGB5_A1_OES)) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ if (width<0 || height<0 || border!=0) {
+ ogles_error(c, GL_INVALID_VALUE);
+ return;
+ }
+
+ // "uncompress" the texture since pixelflinger doesn't support
+ // any compressed texture format natively.
+ GLenum format;
+ GLenum type;
+ switch (internalformat) {
+ case GL_PALETTE8_RGB8_OES:
+ case GL_PALETTE4_RGB8_OES:
+ format = GL_RGB;
+ type = GL_UNSIGNED_BYTE;
+ break;
+ case GL_PALETTE8_RGBA8_OES:
+ case GL_PALETTE4_RGBA8_OES:
+ format = GL_RGBA;
+ type = GL_UNSIGNED_BYTE;
+ break;
+ case GL_PALETTE8_R5_G6_B5_OES:
+ case GL_PALETTE4_R5_G6_B5_OES:
+ format = GL_RGB;
+ type = GL_UNSIGNED_SHORT_5_6_5;
+ break;
+ case GL_PALETTE8_RGBA4_OES:
+ case GL_PALETTE4_RGBA4_OES:
+ format = GL_RGBA;
+ type = GL_UNSIGNED_SHORT_4_4_4_4;
+ break;
+ case GL_PALETTE8_RGB5_A1_OES:
+ case GL_PALETTE4_RGB5_A1_OES:
+ format = GL_RGBA;
+ type = GL_UNSIGNED_SHORT_5_5_5_1;
+ break;
+ default:
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+
+ if (!data || !width || !height) {
+ // unclear if this is an error or not...
+ return;
+ }
+
+ int32_t size;
+ GGLSurface* surface;
+ // all mipmap levels are specified at once.
+ const int numLevels = level<0 ? -level : 1;
+ for (int i=0 ; i<numLevels ; i++) {
+ int lod_w = (width >> i) ? : 1;
+ int lod_h = (height >> i) ? : 1;
+ int error = createTextureSurface(c, &surface, &size,
+ i, format, type, lod_w, lod_h);
+ if (error) {
+ ogles_error(c, error);
+ return;
+ }
+ decodePalette4(data, i, width, height,
+ surface->data, surface->stride, internalformat);
+ }
+}
+
+
+void glTexImage2D(
+ GLenum target, GLint level, GLint internalformat,
+ GLsizei width, GLsizei height, GLint border,
+ GLenum format, GLenum type, const GLvoid *pixels)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if (target != GL_TEXTURE_2D && target != GL_DIRECT_TEXTURE_2D_QUALCOMM) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ if (width<0 || height<0 || border!=0 || level < 0) {
+ ogles_error(c, GL_INVALID_VALUE);
+ return;
+ }
+ if (format != internalformat) {
+ ogles_error(c, GL_INVALID_OPERATION);
+ return;
+ }
+ if (validFormatType(c, format, type)) {
+ return;
+ }
+
+ int32_t size = 0;
+ GGLSurface* surface = 0;
+ if (target != GL_DIRECT_TEXTURE_2D_QUALCOMM) {
+ int error = createTextureSurface(c, &surface, &size,
+ level, format, type, width, height);
+ if (error) {
+ ogles_error(c, error);
+ return;
+ }
+ } else if (pixels == 0 || level != 0) {
+ // pixel can't be null for direct texture
+ ogles_error(c, GL_INVALID_OPERATION);
+ return;
+ }
+
+ if (pixels) {
+ const int32_t formatIdx = convertGLPixelFormat(format, type);
+ const GGLFormat& pixelFormat(c->rasterizer.formats[formatIdx]);
+ const int32_t align = c->textures.unpackAlignment-1;
+ const int32_t bpr = ((width * pixelFormat.size) + align) & ~align;
+ const size_t size = bpr * height;
+ const int32_t stride = bpr / pixelFormat.size;
+
+ GGLSurface userSurface;
+ userSurface.version = sizeof(userSurface);
+ userSurface.width = width;
+ userSurface.height = height;
+ userSurface.stride = stride;
+ userSurface.format = formatIdx;
+ userSurface.compressedFormat = 0;
+ userSurface.data = (GLubyte*)pixels;
+
+ if (target != GL_DIRECT_TEXTURE_2D_QUALCOMM) {
+ int err = copyPixels(c, *surface, 0, 0, userSurface, 0, 0, width, height);
+ if (err) {
+ ogles_error(c, err);
+ return;
+ }
+ generateMipmap(c, level);
+ } else {
+ // bind it to the texture unit
+ sp<EGLTextureObject> tex = getAndBindActiveTextureObject(c);
+ tex->setSurface(&userSurface);
+ }
+ }
+}
+
+// ----------------------------------------------------------------------------
+
+void glCompressedTexSubImage2D(
+ GLenum target, GLint level, GLint xoffset,
+ GLint yoffset, GLsizei width, GLsizei height,
+ GLenum format, GLsizei imageSize,
+ const GLvoid *data)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ ogles_error(c, GL_INVALID_ENUM);
+}
+
+void glTexSubImage2D(
+ GLenum target, GLint level, GLint xoffset,
+ GLint yoffset, GLsizei width, GLsizei height,
+ GLenum format, GLenum type, const GLvoid *pixels)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if (target != GL_TEXTURE_2D) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ if (xoffset<0 || yoffset<0 || width<0 || height<0 || level<0) {
+ ogles_error(c, GL_INVALID_VALUE);
+ return;
+ }
+ if (validFormatType(c, format, type)) {
+ return;
+ }
+
+ // find out which texture is bound to the current unit
+ const int active = c->textures.active;
+ EGLTextureObject* tex = c->textures.tmu[active].texture;
+ const GGLSurface& surface(tex->mip(level));
+
+ if (!tex->internalformat || tex->direct) {
+ ogles_error(c, GL_INVALID_OPERATION);
+ return;
+ }
+ if ((xoffset + width > GLsizei(surface.width)) ||
+ (yoffset + height > GLsizei(surface.height))) {
+ ogles_error(c, GL_INVALID_VALUE);
+ return;
+ }
+ if (!width || !height) {
+ return; // okay, but no-op.
+ }
+
+ // figure out the size we need as well as the stride
+ const int32_t formatIdx = convertGLPixelFormat(format, type);
+ if (formatIdx == 0) { // we don't know what to do with this
+ ogles_error(c, GL_INVALID_OPERATION);
+ return;
+ }
+
+ const GGLFormat& pixelFormat(c->rasterizer.formats[formatIdx]);
+ const int32_t align = c->textures.unpackAlignment-1;
+ const int32_t bpr = ((width * pixelFormat.size) + align) & ~align;
+ const size_t size = bpr * height;
+ const int32_t stride = bpr / pixelFormat.size;
+ GGLSurface userSurface;
+ userSurface.version = sizeof(userSurface);
+ userSurface.width = width;
+ userSurface.height = height;
+ userSurface.stride = stride;
+ userSurface.format = formatIdx;
+ userSurface.compressedFormat = 0;
+ userSurface.data = (GLubyte*)pixels;
+
+ int err = copyPixels(c,
+ surface, xoffset, yoffset,
+ userSurface, 0, 0, width, height);
+ if (err) {
+ ogles_error(c, err);
+ return;
+ }
+
+ generateMipmap(c, level);
+
+ // since we only changed the content of the texture, we don't need
+ // to call bindTexture on the main rasterizer.
+}
+
+// ----------------------------------------------------------------------------
+
+void glCopyTexImage2D(
+ GLenum target, GLint level, GLenum internalformat,
+ GLint x, GLint y, GLsizei width, GLsizei height,
+ GLint border)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if (target != GL_TEXTURE_2D) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ if (internalformat<GL_ALPHA || internalformat>GL_LUMINANCE_ALPHA) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ if (width<0 || height<0 || border!=0 || level<0) {
+ ogles_error(c, GL_INVALID_VALUE);
+ return;
+ }
+
+ GLenum format = 0;
+ GLenum type = GL_UNSIGNED_BYTE;
+ const GGLSurface& cbSurface = c->rasterizer.state.buffers.color.s;
+ const int cbFormatIdx = cbSurface.format;
+ switch (cbFormatIdx) {
+ case GGL_PIXEL_FORMAT_RGB_565:
+ type = GL_UNSIGNED_SHORT_5_6_5;
+ break;
+ case GGL_PIXEL_FORMAT_RGBA_5551:
+ type = GL_UNSIGNED_SHORT_5_5_5_1;
+ break;
+ case GGL_PIXEL_FORMAT_RGBA_4444:
+ type = GL_UNSIGNED_SHORT_4_4_4_4;
+ break;
+ }
+ switch (internalformat) {
+ case GL_ALPHA:
+ case GL_LUMINANCE_ALPHA:
+ case GL_LUMINANCE:
+ type = GL_UNSIGNED_BYTE;
+ break;
+ }
+
+ // figure out the format to use for the new texture
+ switch (cbFormatIdx) {
+ case GGL_PIXEL_FORMAT_RGBA_8888:
+ case GGL_PIXEL_FORMAT_A_8:
+ case GGL_PIXEL_FORMAT_RGBA_5551:
+ case GGL_PIXEL_FORMAT_RGBA_4444:
+ format = internalformat;
+ break;
+ case GGL_PIXEL_FORMAT_RGBX_8888:
+ case GGL_PIXEL_FORMAT_RGB_888:
+ case GGL_PIXEL_FORMAT_RGB_565:
+ case GGL_PIXEL_FORMAT_L_8:
+ switch (internalformat) {
+ case GL_LUMINANCE:
+ case GL_RGB:
+ format = internalformat;
+ break;
+ }
+ break;
+ }
+
+ if (format == 0) {
+ // invalid combination
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+
+ // create the new texture...
+ int32_t size;
+ GGLSurface* surface;
+ int error = createTextureSurface(c, &surface, &size,
+ level, format, type, width, height);
+ if (error) {
+ ogles_error(c, error);
+ return;
+ }
+
+ // The bottom row is stored first in textures
+ GGLSurface txSurface(*surface);
+ txSurface.stride = -txSurface.stride;
+
+ // (x,y) is the lower-left corner of colorBuffer
+ y = cbSurface.height - (y + height);
+
+ int err = copyPixels(c,
+ txSurface, 0, 0,
+ cbSurface, x, y, cbSurface.width, cbSurface.height);
+ if (err) {
+ ogles_error(c, err);
+ }
+
+ generateMipmap(c, level);
+}
+
+void glCopyTexSubImage2D(
+ GLenum target, GLint level, GLint xoffset, GLint yoffset,
+ GLint x, GLint y, GLsizei width, GLsizei height)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if (target != GL_TEXTURE_2D) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ if (xoffset<0 || yoffset<0 || width<0 || height<0 || level<0) {
+ ogles_error(c, GL_INVALID_VALUE);
+ return;
+ }
+ if (!width || !height) {
+ return; // okay, but no-op.
+ }
+
+ // find out which texture is bound to the current unit
+ const int active = c->textures.active;
+ EGLTextureObject* tex = c->textures.tmu[active].texture;
+ const GGLSurface& surface(tex->mip(level));
+
+ if (!tex->internalformat) {
+ ogles_error(c, GL_INVALID_OPERATION);
+ return;
+ }
+ if ((xoffset + width > GLsizei(surface.width)) ||
+ (yoffset + height > GLsizei(surface.height))) {
+ ogles_error(c, GL_INVALID_VALUE);
+ return;
+ }
+
+ // The bottom row is stored first in textures
+ GGLSurface txSurface(surface);
+ txSurface.stride = -txSurface.stride;
+
+ // (x,y) is the lower-left corner of colorBuffer
+ const GGLSurface& cbSurface = c->rasterizer.state.buffers.color.s;
+ y = cbSurface.height - (y + height);
+
+ int err = copyPixels(c,
+ surface, xoffset, yoffset,
+ cbSurface, x, y, width, height);
+ if (err) {
+ ogles_error(c, err);
+ return;
+ }
+
+ generateMipmap(c, level);
+}
+
+void glReadPixels(
+ GLint x, GLint y, GLsizei width, GLsizei height,
+ GLenum format, GLenum type, GLvoid *pixels)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ if ((format != GL_RGBA) && (format != GL_RGB)) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ if ((type != GL_UNSIGNED_BYTE) && (type != GL_UNSIGNED_SHORT_5_6_5)) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+ if (width<0 || height<0) {
+ ogles_error(c, GL_INVALID_VALUE);
+ return;
+ }
+ if (x<0 || x<0) {
+ ogles_error(c, GL_INVALID_VALUE);
+ return;
+ }
+
+ int32_t formatIdx = GGL_PIXEL_FORMAT_NONE;
+ if ((format == GL_RGBA) && (type == GL_UNSIGNED_BYTE)) {
+ formatIdx = GGL_PIXEL_FORMAT_RGBA_8888;
+ } else if ((format == GL_RGB) && (type == GL_UNSIGNED_SHORT_5_6_5)) {
+ formatIdx = GGL_PIXEL_FORMAT_RGB_565;
+ } else {
+ ogles_error(c, GL_INVALID_OPERATION);
+ return;
+ }
+
+ const GGLSurface& readSurface = c->rasterizer.state.buffers.read.s;
+ if ((x+width > GLint(readSurface.width)) ||
+ (y+height > GLint(readSurface.height))) {
+ ogles_error(c, GL_INVALID_VALUE);
+ return;
+ }
+
+ const GGLFormat& pixelFormat(c->rasterizer.formats[formatIdx]);
+ const int32_t align = c->textures.packAlignment-1;
+ const int32_t bpr = ((width * pixelFormat.size) + align) & ~align;
+ const int32_t stride = bpr / pixelFormat.size;
+
+ GGLSurface userSurface;
+ userSurface.version = sizeof(userSurface);
+ userSurface.width = width;
+ userSurface.height = height;
+ userSurface.stride = -stride; // bottom row is transfered first
+ userSurface.format = formatIdx;
+ userSurface.compressedFormat = 0;
+ userSurface.data = (GLubyte*)pixels;
+
+ // use pixel-flinger to handle all the conversions
+ GGLContext* ggl = getRasterizer(c);
+ if (!ggl) {
+ // the only reason this would fail is because we ran out of memory
+ ogles_error(c, GL_OUT_OF_MEMORY);
+ return;
+ }
+
+ ggl->colorBuffer(ggl, &userSurface); // destination is user buffer
+ ggl->bindTexture(ggl, &readSurface); // source is read-buffer
+ ggl->texCoord2i(ggl, x, readSurface.height - (y + height));
+ ggl->recti(ggl, 0, 0, width, height);
+}
+
+// ----------------------------------------------------------------------------
+#if 0
+#pragma mark -
+#pragma mark DrawTexture Extension
+#endif
+
+void glDrawTexsvOES(const GLshort* coords) {
+ ogles_context_t* c = ogles_context_t::get();
+ drawTexiOES(coords[0], coords[1], coords[2], coords[3], coords[4], c);
+}
+void glDrawTexivOES(const GLint* coords) {
+ ogles_context_t* c = ogles_context_t::get();
+ drawTexiOES(coords[0], coords[1], coords[2], coords[3], coords[4], c);
+}
+void glDrawTexsOES(GLshort x , GLshort y, GLshort z, GLshort w, GLshort h) {
+ ogles_context_t* c = ogles_context_t::get();
+ drawTexiOES(x, y, z, w, h, c);
+}
+void glDrawTexiOES(GLint x, GLint y, GLint z, GLint w, GLint h) {
+ ogles_context_t* c = ogles_context_t::get();
+ drawTexiOES(x, y, z, w, h, c);
+}
+
+void glDrawTexfvOES(const GLfloat* coords) {
+ ogles_context_t* c = ogles_context_t::get();
+ drawTexxOES(
+ gglFloatToFixed(coords[0]),
+ gglFloatToFixed(coords[1]),
+ gglFloatToFixed(coords[2]),
+ gglFloatToFixed(coords[3]),
+ gglFloatToFixed(coords[4]),
+ c);
+}
+void glDrawTexxvOES(const GLfixed* coords) {
+ ogles_context_t* c = ogles_context_t::get();
+ drawTexxOES(coords[0], coords[1], coords[2], coords[3], coords[4], c);
+}
+void glDrawTexfOES(GLfloat x, GLfloat y, GLfloat z, GLfloat w, GLfloat h){
+ ogles_context_t* c = ogles_context_t::get();
+ drawTexxOES(
+ gglFloatToFixed(x), gglFloatToFixed(y), gglFloatToFixed(z),
+ gglFloatToFixed(w), gglFloatToFixed(h),
+ c);
+}
+void glDrawTexxOES(GLfixed x, GLfixed y, GLfixed z, GLfixed w, GLfixed h) {
+ ogles_context_t* c = ogles_context_t::get();
+ drawTexxOES(x, y, z, w, h, c);
+}
diff --git a/opengl/libagl/texture.h b/opengl/libagl/texture.h
new file mode 100644
index 0000000..5c57948
--- /dev/null
+++ b/opengl/libagl/texture.h
@@ -0,0 +1,45 @@
+/* libs/opengles/texture.h
+**
+** Copyright 2006, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+** http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+#ifndef ANDROID_OPENGLES_TEXTURE_H
+#define ANDROID_OPENGLES_TEXTURE_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include <sys/types.h>
+
+#include <private/pixelflinger/ggl_context.h>
+
+#include <GLES/gl.h>
+
+#include "context.h"
+
+namespace android {
+
+void ogles_init_texture(ogles_context_t* c);
+void ogles_uninit_texture(ogles_context_t* c);
+void ogles_validate_texture_impl(ogles_context_t* c);
+
+inline void ogles_validate_texture(ogles_context_t* c) {
+ if (c->rasterizer.state.enables & GGL_ENABLE_TMUS)
+ ogles_validate_texture_impl(c);
+}
+
+
+}; // namespace android
+
+#endif // ANDROID_OPENGLES_TEXTURE_H
diff --git a/opengl/libagl/vertex.cpp b/opengl/libagl/vertex.cpp
new file mode 100644
index 0000000..dad04d6
--- /dev/null
+++ b/opengl/libagl/vertex.cpp
@@ -0,0 +1,247 @@
+/* libs/opengles/vertex.cpp
+**
+** Copyright 2006, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+** http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+#include <stdio.h>
+#include <stdlib.h>
+#include "context.h"
+#include "fp.h"
+#include "vertex.h"
+#include "state.h"
+#include "matrix.h"
+
+namespace android {
+
+// ----------------------------------------------------------------------------
+
+void ogles_init_vertex(ogles_context_t* c)
+{
+ c->cull.enable = GL_FALSE;
+ c->cull.cullFace = GL_BACK;
+ c->cull.frontFace = GL_CCW;
+
+ c->current.color.r = 0x10000;
+ c->current.color.g = 0x10000;
+ c->current.color.b = 0x10000;
+ c->current.color.a = 0x10000;
+
+ c->currentNormal.z = 0x10000;
+}
+
+void ogles_uninit_vertex(ogles_context_t* c)
+{
+}
+
+// ----------------------------------------------------------------------------
+// vertex processing
+// ----------------------------------------------------------------------------
+
+// Divides a vertex clip coordinates by W
+static inline
+void perspective(ogles_context_t* c, vertex_t* v, uint32_t enables)
+{
+ // [x,y,z]window = vpt * ([x,y,z]clip / clip.w)
+ // [w]window = 1/w
+
+ // With a regular projection generated by glFrustum(),
+ // we have w=-z, therefore, w is in [zNear, zFar].
+ // Also, zNear and zFar are stricly positive,
+ // and 1/w (window.w) is in [1/zFar, 1/zNear], usually this
+ // means ]0, +inf[ -- however, it is always recommended
+ // to use as large values as possible for zNear.
+ // All in all, w is usually smaller than 1.0 (assuming
+ // zNear is at least 1.0); and even if zNear is smaller than 1.0
+ // values of w won't be too big.
+
+ const int32_t rw = gglRecip28(v->clip.w);
+ const GLfixed* const m = c->transforms.vpt.transform.matrix.m;
+ v->window.w = rw;
+ v->window.x = gglMulAddx(gglMulx(v->clip.x, rw, 16), m[ 0], m[12], 28);
+ v->window.y = gglMulAddx(gglMulx(v->clip.y, rw, 16), m[ 5], m[13], 28);
+ v->window.x = TRI_FROM_FIXED(v->window.x);
+ v->window.y = TRI_FROM_FIXED(v->window.y);
+ if (enables & GGL_ENABLE_DEPTH_TEST) {
+ v->window.z = gglMulAddx(gglMulx(v->clip.z, rw, 16), m[10], m[14], 28);
+ }
+}
+
+// frustum clipping and W-divide
+static inline
+void clipFrustumPerspective(ogles_context_t* c, vertex_t* v, uint32_t enables)
+{
+ // ndc = clip / W
+ // window = ncd * viewport
+
+ // clip to the view-volume
+ uint32_t clip = v->flags & vertex_t::CLIP_ALL;
+ const GLfixed w = v->clip.w;
+ if (v->clip.x < -w) clip |= vertex_t::CLIP_L;
+ if (v->clip.x > w) clip |= vertex_t::CLIP_R;
+ if (v->clip.y < -w) clip |= vertex_t::CLIP_B;
+ if (v->clip.y > w) clip |= vertex_t::CLIP_T;
+ if (v->clip.z < -w) clip |= vertex_t::CLIP_N;
+ if (v->clip.z > w) clip |= vertex_t::CLIP_F;
+
+ v->flags |= clip;
+ c->arrays.cull &= clip;
+
+ if (ggl_likely(!clip)) {
+ // if the vertex is clipped, we don't do the perspective
+ // divide, since we don't need its window coordinates.
+ perspective(c, v, enables);
+ }
+}
+
+// frustum clipping, user clipping and W-divide
+static inline
+void clipAllPerspective(ogles_context_t* c, vertex_t* v, uint32_t enables)
+{
+ // compute eye coordinates
+ c->arrays.mv_transform(
+ &c->transforms.modelview.transform, &v->eye, &v->obj);
+ v->flags |= vertex_t::EYE;
+
+ // clip this vertex against each user clip plane
+ uint32_t clip = 0;
+ int planes = c->clipPlanes.enable;
+ while (planes) {
+ const int i = 31 - gglClz(planes);
+ planes &= ~(1<<i);
+ // XXX: we should have a special dot() for 2,3,4 coords vertices
+ GLfixed d = dot4(c->clipPlanes.plane[i].equation.v, v->eye.v);
+ if (d < 0) {
+ clip |= 0x100<<i;
+ }
+ }
+ v->flags |= clip;
+
+ clipFrustumPerspective(c, v, enables);
+}
+
+// ----------------------------------------------------------------------------
+
+void ogles_vertex_project(ogles_context_t* c, vertex_t* v) {
+ perspective(c, v, c->rasterizer.state.enables);
+}
+
+void ogles_vertex_perspective2D(ogles_context_t* c, vertex_t* v)
+{
+ // here we assume w=1.0 and the viewport transformation
+ // has been applied already.
+ c->arrays.cull = 0;
+ v->window.x = TRI_FROM_FIXED(v->clip.x);
+ v->window.y = TRI_FROM_FIXED(v->clip.y);
+ v->window.z = v->clip.z;
+ v->window.w = v->clip.w << 12;
+}
+
+void ogles_vertex_perspective3DZ(ogles_context_t* c, vertex_t* v) {
+ clipFrustumPerspective(c, v, GGL_ENABLE_DEPTH_TEST);
+}
+void ogles_vertex_perspective3D(ogles_context_t* c, vertex_t* v) {
+ clipFrustumPerspective(c, v, 0);
+}
+void ogles_vertex_clipAllPerspective3DZ(ogles_context_t* c, vertex_t* v) {
+ clipAllPerspective(c, v, GGL_ENABLE_DEPTH_TEST);
+}
+void ogles_vertex_clipAllPerspective3D(ogles_context_t* c, vertex_t* v) {
+ clipAllPerspective(c, v, 0);
+}
+
+static void clipPlanex(GLenum plane, const GLfixed* equ, ogles_context_t* c)
+{
+ const int p = plane - GL_CLIP_PLANE0;
+ if (ggl_unlikely(uint32_t(p) > (GL_CLIP_PLANE5 - GL_CLIP_PLANE0))) {
+ ogles_error(c, GL_INVALID_ENUM);
+ return;
+ }
+
+ vec4_t& equation = c->clipPlanes.plane[p].equation;
+ memcpy(equation.v, equ, sizeof(vec4_t));
+
+ ogles_validate_transform(c, transform_state_t::MVIT);
+ transform_t& mvit = c->transforms.mvit4;
+ mvit.point4(&mvit, &equation, &equation);
+}
+
+// ----------------------------------------------------------------------------
+}; // namespace android
+// ----------------------------------------------------------------------------
+
+using namespace android;
+
+
+void glColor4f(GLfloat r, GLfloat g, GLfloat b, GLfloat a)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ c->current.color.r = gglFloatToFixed(r);
+ c->currentColorClamped.r = gglClampx(c->current.color.r);
+ c->current.color.g = gglFloatToFixed(g);
+ c->currentColorClamped.g = gglClampx(c->current.color.g);
+ c->current.color.b = gglFloatToFixed(b);
+ c->currentColorClamped.b = gglClampx(c->current.color.b);
+ c->current.color.a = gglFloatToFixed(a);
+ c->currentColorClamped.a = gglClampx(c->current.color.a);
+}
+
+void glColor4x(GLfixed r, GLfixed g, GLfixed b, GLfixed a)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ c->current.color.r = r;
+ c->current.color.g = g;
+ c->current.color.b = b;
+ c->current.color.a = a;
+ c->currentColorClamped.r = gglClampx(r);
+ c->currentColorClamped.g = gglClampx(g);
+ c->currentColorClamped.b = gglClampx(b);
+ c->currentColorClamped.a = gglClampx(a);
+}
+
+void glNormal3f(GLfloat x, GLfloat y, GLfloat z)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ c->currentNormal.x = gglFloatToFixed(x);
+ c->currentNormal.y = gglFloatToFixed(y);
+ c->currentNormal.z = gglFloatToFixed(z);
+}
+
+void glNormal3x(GLfixed x, GLfixed y, GLfixed z)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ c->currentNormal.x = x;
+ c->currentNormal.y = y;
+ c->currentNormal.z = z;
+}
+
+// ----------------------------------------------------------------------------
+
+void glClipPlanef(GLenum plane, const GLfloat* equ)
+{
+ const GLfixed equx[4] = {
+ gglFloatToFixed(equ[0]),
+ gglFloatToFixed(equ[1]),
+ gglFloatToFixed(equ[2]),
+ gglFloatToFixed(equ[3])
+ };
+ ogles_context_t* c = ogles_context_t::get();
+ clipPlanex(plane, equx, c);
+}
+
+void glClipPlanex(GLenum plane, const GLfixed* equ)
+{
+ ogles_context_t* c = ogles_context_t::get();
+ clipPlanex(plane, equ, c);
+}
diff --git a/opengl/libagl/vertex.h b/opengl/libagl/vertex.h
new file mode 100644
index 0000000..55e6213
--- /dev/null
+++ b/opengl/libagl/vertex.h
@@ -0,0 +1,48 @@
+/* libs/opengles/vertex.h
+**
+** Copyright 2006, The Android Open Source Project
+**
+** Licensed under the Apache License, Version 2.0 (the "License");
+** you may not use this file except in compliance with the License.
+** You may obtain a copy of the License at
+**
+** http://www.apache.org/licenses/LICENSE-2.0
+**
+** Unless required by applicable law or agreed to in writing, software
+** distributed under the License is distributed on an "AS IS" BASIS,
+** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+** See the License for the specific language governing permissions and
+** limitations under the License.
+*/
+
+#ifndef ANDROID_OPENGLES_VERTEX_H
+#define ANDROID_OPENGLES_VERTEX_H
+
+#include <stdint.h>
+#include <stddef.h>
+#include <sys/types.h>
+
+namespace android {
+
+namespace gl {
+struct vertex_t;
+struct ogles_context_t;
+};
+
+void ogles_init_vertex(ogles_context_t* c);
+void ogles_uninit_vertex(ogles_context_t* c);
+
+void ogles_vertex_perspective2D(ogles_context_t*, vertex_t*);
+
+void ogles_vertex_perspective3D(ogles_context_t*, vertex_t*);
+void ogles_vertex_perspective3DZ(ogles_context_t*, vertex_t*);
+void ogles_vertex_clipAllPerspective3D(ogles_context_t*, vertex_t*);
+void ogles_vertex_clipAllPerspective3DZ(ogles_context_t*, vertex_t*);
+
+
+void ogles_vertex_project(ogles_context_t* c, vertex_t*);
+
+}; // namespace android
+
+#endif // ANDROID_OPENGLES_VERTEX_H
+