diff --git a/tools/emulator/opengl/host/libs/Translator/GLcommon/Android.mk b/tools/emulator/opengl/host/libs/Translator/GLcommon/Android.mk new file mode 100644 index 000000000..2ba9a381f --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/GLcommon/Android.mk @@ -0,0 +1,21 @@ + +LOCAL_PATH := $(call my-dir) + +### EGL host implementation ######################## +include $(CLEAR_VARS) + +translator_path := $(LOCAL_PATH)/.. + +LOCAL_SRC_FILES := \ + GLutils.cpp \ + objectNameManager.cpp + + +LOCAL_C_INCLUDES += \ + $(translator_path)/include + +LOCAL_CFLAGS := -g -O0 +LOCAL_MODULE_TAGS := debug +LOCAL_MODULE := libGLcommon + +include $(BUILD_HOST_STATIC_LIBRARY) diff --git a/tools/emulator/opengl/host/libs/Translator/GLcommon/GLutils.cpp b/tools/emulator/opengl/host/libs/Translator/GLcommon/GLutils.cpp new file mode 100644 index 000000000..46e292c23 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/GLcommon/GLutils.cpp @@ -0,0 +1,20 @@ +/* +* Copyright (C) 2011 The Android Open Source Project +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ +#include + +bool isPowerOf2(int num) { + return (num & (num -1)) == 0; +} diff --git a/tools/emulator/opengl/host/libs/Translator/GLcommon/objectNameManager.cpp b/tools/emulator/opengl/host/libs/Translator/GLcommon/objectNameManager.cpp new file mode 100644 index 000000000..d49849888 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/GLcommon/objectNameManager.cpp @@ -0,0 +1,376 @@ +/* +* Copyright (C) 2011 The Android Open Source Project +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ +#include +#include + +class GlobalNameSpace +{ +public: + GlobalNameSpace() + { + mutex_init(&m_lock); + + for (int i=0; i= NUM_OBJECT_TYPES ) return 0; + + mutex_lock(&m_lock); + unsigned int name = m_nameSpace[p_type]->genName(0, false); + mutex_unlock(&m_lock); + return name; + } + + void deleteName(NamedObjectType p_type, unsigned int p_name) + { + if ( p_type >= NUM_OBJECT_TYPES ) return; + + mutex_lock(&m_lock); + m_nameSpace[p_type]->deleteName(p_name); + mutex_unlock(&m_lock); + } + +private: + mutex_t m_lock; + NameSpace *m_nameSpace[NUM_OBJECT_TYPES]; +}; + +static GlobalNameSpace *s_globalNameSpace = NULL; + +NameSpace::NameSpace(NamedObjectType p_type) : + m_nextName(0), + m_type(p_type) +{ +} + +NameSpace::~NameSpace() +{ + for (NamesMap::iterator n = m_localToGlobalMap.begin(); + n != m_localToGlobalMap.end(); + n++) { + s_globalNameSpace->deleteName(m_type, (*n).second); + } +} + +unsigned int +NameSpace::genName(unsigned int p_localName, bool genGlobal) +{ + + unsigned int localName = p_localName; + if (localName == 0) { + do { + localName = ++m_nextName; + } while( localName == 0 || m_localToGlobalMap.find(localName) != m_localToGlobalMap.end() ); + } + + if (genGlobal) { + unsigned int globalName = s_globalNameSpace->genName(m_type); + m_localToGlobalMap[localName] = globalName; + } + + return localName; +} + +unsigned int +NameSpace::getGlobalName(unsigned int p_localName) +{ + NamesMap::iterator n( m_localToGlobalMap.find(p_localName) ); + if (n != m_localToGlobalMap.end()) { + // object found - return its global name map + return (*n).second; + } + + // object does not exist; + return 0; +} + +void +NameSpace::deleteName(unsigned int p_localName) +{ + NamesMap::iterator n( m_localToGlobalMap.find(p_localName) ); + if (n != m_localToGlobalMap.end()) { + s_globalNameSpace->deleteName(m_type, (*n).second); + m_localToGlobalMap.erase(p_localName); + } +} + +bool +NameSpace::isObject(unsigned int p_localName) +{ + return (m_localToGlobalMap.find(p_localName) != m_localToGlobalMap.end() ); +} + +void +NameSpace::replaceGlobalName(unsigned int p_localName, unsigned int p_globalName) +{ + NamesMap::iterator n( m_localToGlobalMap.find(p_localName) ); + if (n != m_localToGlobalMap.end()) { + s_globalNameSpace->deleteName(m_type, (*n).second); + (*n).second = p_globalName; + } +} + +typedef std::pair ObjectIDPair; +typedef std::map ObjectDataMap; + +ShareGroup::ShareGroup() +{ + mutex_init(&m_lock); + + for (int i=0; i= NUM_OBJECT_TYPES) return 0; + + mutex_lock(&m_lock); + unsigned int localName = m_nameSpace[p_type]->genName(p_localName); + mutex_unlock(&m_lock); + + return localName; +} + +unsigned int +ShareGroup::getGlobalName(NamedObjectType p_type, unsigned int p_localName) +{ + if (p_type >= NUM_OBJECT_TYPES) return 0; + + mutex_lock(&m_lock); + unsigned int globalName = m_nameSpace[p_type]->getGlobalName(p_localName); + mutex_unlock(&m_lock); + + return globalName; +} + +void +ShareGroup::deleteName(NamedObjectType p_type, unsigned int p_localName) +{ + if (p_type >= NUM_OBJECT_TYPES) return; + + mutex_lock(&m_lock); + m_nameSpace[p_type]->deleteName(p_localName); + ObjectDataMap *map = (ObjectDataMap *)m_objectsData; + if (map) { + map->erase( ObjectIDPair(p_type, p_localName) ); + } + mutex_unlock(&m_lock); +} + +bool +ShareGroup::isObject(NamedObjectType p_type, unsigned int p_localName) +{ + if (p_type >= NUM_OBJECT_TYPES) return 0; + + mutex_lock(&m_lock); + bool exist = m_nameSpace[p_type]->isObject(p_localName); + mutex_unlock(&m_lock); + + return exist; +} + +void +ShareGroup::replaceGlobalName(NamedObjectType p_type, unsigned int p_localName, unsigned int p_globalName) +{ + if (p_type >= NUM_OBJECT_TYPES) return; + + mutex_lock(&m_lock); + m_nameSpace[p_type]->replaceGlobalName(p_localName, p_globalName); + mutex_unlock(&m_lock); +} + +void +ShareGroup::setObjectData(NamedObjectType p_type, unsigned int p_localName, ObjectDataPtr data) +{ + if (p_type >= NUM_OBJECT_TYPES) return; + + mutex_lock(&m_lock); + + ObjectDataMap *map = (ObjectDataMap *)m_objectsData; + if (!map) { + map = new ObjectDataMap(); + m_objectsData = map; + } + + ObjectIDPair id( p_type, p_localName ); + map->insert( std::pair(id, data) ); + + mutex_unlock(&m_lock); +} + +ObjectDataPtr +ShareGroup::getObjectData(NamedObjectType p_type, unsigned int p_localName) +{ + ObjectDataPtr ret; + + if (p_type >= NUM_OBJECT_TYPES) return ret; + + mutex_lock(&m_lock); + + ObjectDataMap *map = (ObjectDataMap *)m_objectsData; + if (map) { + ObjectDataMap::iterator i = map->find( ObjectIDPair(p_type, p_localName) ); + if (i != map->end()) ret = (*i).second; + } + + mutex_unlock(&m_lock); + + return ret; +} + +ObjectNameManager::ObjectNameManager() +{ + mutex_init(&m_lock); +} + +ObjectNameManager::~ObjectNameManager() +{ + mutex_destroy(&m_lock); +} + +ShareGroupPtr +ObjectNameManager::createShareGroup(void *p_groupName) +{ + mutex_lock(&m_lock); + + if (!s_globalNameSpace) s_globalNameSpace = new GlobalNameSpace(); + + ShareGroupPtr shareGroupReturn; + + ShareGroupsMap::iterator s( m_groups.find(p_groupName) ); + if (s != m_groups.end()) { + shareGroupReturn = (*s).second; + } + else { + // + // Group does not exist, create new group + // + shareGroupReturn = ShareGroupPtr( new ShareGroup() ); + m_groups.insert( std::pair(p_groupName, shareGroupReturn) ); + } + + mutex_unlock(&m_lock); + + return shareGroupReturn; +} + +ShareGroupPtr +ObjectNameManager::getShareGroup(void *p_groupName) +{ + mutex_lock(&m_lock); + + if (!s_globalNameSpace) s_globalNameSpace = new GlobalNameSpace(); + + ShareGroupPtr shareGroupReturn(NULL); + + ShareGroupsMap::iterator s( m_groups.find(p_groupName) ); + if (s != m_groups.end()) { + shareGroupReturn = (*s).second; + } + mutex_unlock(&m_lock); + + return shareGroupReturn; +} + +ShareGroupPtr +ObjectNameManager::attachShareGroup(void *p_groupName, void *p_existingGroupName) +{ + mutex_lock(&m_lock); + + if (!s_globalNameSpace) s_globalNameSpace = new GlobalNameSpace(); + + ShareGroupPtr shareGroupReturn; + + ShareGroupsMap::iterator s( m_groups.find(p_existingGroupName) ); + if (s == m_groups.end()) { + // ShareGroup did not found !!! + mutex_unlock(&m_lock); + return ShareGroupPtr(NULL); + } + + shareGroupReturn = (*s).second; + + if (m_groups.find(p_groupName) == m_groups.end()) + { + m_groups.insert( std::pair(p_groupName, shareGroupReturn) ); + } + + mutex_unlock(&m_lock); + + return shareGroupReturn; +} + +void +ObjectNameManager::deleteShareGroup(void *p_groupName) +{ + mutex_lock(&m_lock); + + ShareGroupsMap::iterator s( m_groups.find(p_groupName) ); + if (s != m_groups.end()) { + m_groups.erase(s); + } + + if (m_groups.size() == 0 && s_globalNameSpace) { + delete s_globalNameSpace; + s_globalNameSpace = NULL; + } + mutex_unlock(&m_lock); +} + +void *ObjectNameManager::getGlobalContext() +{ + void *ret = NULL; + + mutex_lock(&m_lock); + if (m_groups.size() > 0) ret = (*m_groups.begin()).first; + mutex_unlock(&m_lock); + + return ret; +} diff --git a/tools/emulator/opengl/host/libs/Translator/include/GLcommon/GLutils.h b/tools/emulator/opengl/host/libs/Translator/include/GLcommon/GLutils.h new file mode 100644 index 000000000..2da321ab9 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/include/GLcommon/GLutils.h @@ -0,0 +1,29 @@ +/* +* Copyright (C) 2011 The Android Open Source Project +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ +#ifndef GL_UTILS_H +#define GL_UTILS_H + +template +void swap(T& x,T& y) { + T temp; + temp=x; + x=y; + y=temp; +} + +bool isPowerOf2(int num); + +#endif diff --git a/tools/emulator/opengl/host/libs/Translator/include/GLcommon/SmartPtr.h b/tools/emulator/opengl/host/libs/Translator/include/GLcommon/SmartPtr.h new file mode 100644 index 000000000..4bdfbe410 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/include/GLcommon/SmartPtr.h @@ -0,0 +1,167 @@ +/* +* Copyright (C) 2011 The Android Open Source Project +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ +#ifndef __SMART_PTR_H +#define __SMART_PTR_H + +#include +#include + +template +class SmartPtr +{ +public: + explicit SmartPtr(T* ptr = (T*)NULL) { + if (threadSafe) { + m_lock = new mutex_t; + mutex_init(m_lock); + } + else m_lock = NULL; + + m_ptr = ptr; + if (ptr) + m_pRefCount = new int32_t(1); + else + m_pRefCount = NULL; + } + + SmartPtr(const SmartPtr& rhs) { + if (threadSafe) { + m_lock = new mutex_t; + mutex_init(m_lock); + } + else m_lock = NULL; + + m_pRefCount = rhs.m_pRefCount; + m_ptr = rhs.m_ptr; + use(); + } + + SmartPtr(SmartPtr& rhs) { + if (threadSafe) { + m_lock = new mutex_t; + mutex_init(m_lock); + } + else m_lock = NULL; + + if (rhs.m_lock) mutex_lock(rhs.m_lock); + m_pRefCount = rhs.m_pRefCount; + m_ptr = rhs.m_ptr; + use(); + if (rhs.m_lock) mutex_unlock(rhs.m_lock); + } + + ~SmartPtr() { + if (m_lock) mutex_lock(m_lock); + release(); + if (m_lock) + { + mutex_unlock(m_lock); + mutex_destroy(m_lock); + delete m_lock; + } + } + + T* Ptr() const { + return m_ptr; + } + + const T* constPtr() const + { + return m_ptr; + } + + T* operator->() const { + return m_ptr; + } + + T& operator*() const { + return *m_ptr; + } + + operator void*() const { + return (void *)m_ptr; + } + + // This gives STL lists something to compare. + bool operator <(const SmartPtr& t1) const { + return m_ptr < t1.m_ptr; + } + + SmartPtr& operator=(const SmartPtr& rhs) + { + if (m_ptr == rhs.m_ptr) + return *this; + + if (m_lock) mutex_lock(m_lock); + release(); + m_pRefCount = rhs.m_pRefCount; + m_ptr = rhs.m_ptr; + use(); + if (m_lock) mutex_unlock(m_lock); + + return *this; + } + + SmartPtr& operator=(SmartPtr& rhs) + { + if (m_ptr == rhs.m_ptr) + return *this; + + if (m_lock) mutex_lock(m_lock); + release(); + if (rhs.m_lock) mutex_lock(rhs.m_lock); + m_pRefCount = rhs.m_pRefCount; + m_ptr = rhs.m_ptr; + use(); + if (rhs.m_lock) mutex_unlock(rhs.m_lock); + if (m_lock) mutex_unlock(m_lock); + + return *this; + } + +private: + int32_t *m_pRefCount; + mutex_t *m_lock; + T* m_ptr; + + // Increment the reference count on this pointer by 1. + int use() { + if (!m_pRefCount) return 0; + return android_atomic_inc(m_pRefCount) + 1; + } + + // Decrement the reference count on the pointer by 1. + // If the reference count goes to (or below) 0, the pointer is deleted. + int release() { + if (!m_pRefCount) return 0; + + int iVal = android_atomic_dec(m_pRefCount); + if (iVal > 1) + return iVal - 1; + + delete m_pRefCount; + m_pRefCount = NULL; + + if (m_ptr) { + delete m_ptr; + m_ptr = NULL; + } + return 0; + } + +}; + +#endif // of __SMART_PTR_H diff --git a/tools/emulator/opengl/host/libs/Translator/include/GLcommon/ThreadInfo.h b/tools/emulator/opengl/host/libs/Translator/include/GLcommon/ThreadInfo.h new file mode 100644 index 000000000..ba451e684 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/include/GLcommon/ThreadInfo.h @@ -0,0 +1,33 @@ +/* +* Copyright (C) 2011 The Android Open Source Project +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ +#ifndef THREAD_INFO_H +#define THREAD_INFO_H + +#include "objectNameManager.h" + +struct ThreadInfo { + ThreadInfo():eglContext(NULL),glesContext(NULL),objManager(NULL){} + void updateInfo(void* eglctx,void* dpy,void* glesCtx,ShareGroupPtr share,ObjectNameManager* manager); + void* eglContext; + void* eglDisplay; + void* glesContext; + ShareGroupPtr shareGroup; + ObjectNameManager* objManager; +}; + +ThreadInfo* getThreadInfo(); + +#endif diff --git a/tools/emulator/opengl/host/libs/Translator/include/GLcommon/TranslatorIfaces.h b/tools/emulator/opengl/host/libs/Translator/include/GLcommon/TranslatorIfaces.h new file mode 100644 index 000000000..dbf1eb901 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/include/GLcommon/TranslatorIfaces.h @@ -0,0 +1,40 @@ +/* +* Copyright (C) 2011 The Android Open Source Project +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ +#ifndef TRANSLATOR_IFACES_H +#define TRANSLATOR_IFACES_H +#include + +extern "C" { + +class GLEScontext; + +typedef struct { + GLEScontext* (*createGLESContext)(); + void (*initContext)(GLEScontext*); + void (*deleteGLESContext)(GLEScontext*); + void (*flush)(); + void (*finish)(); +}GLESiface; + + +typedef struct { + ThreadInfo* (*getThreadInfo)(); +}EGLiface; + +typedef GLESiface* (*__translator_getGLESIfaceFunc)(EGLiface*); + +} +#endif diff --git a/tools/emulator/opengl/host/libs/Translator/include/GLcommon/objectNameManager.h b/tools/emulator/opengl/host/libs/Translator/include/GLcommon/objectNameManager.h new file mode 100644 index 000000000..ea6afc036 --- /dev/null +++ b/tools/emulator/opengl/host/libs/Translator/include/GLcommon/objectNameManager.h @@ -0,0 +1,220 @@ +/* +* Copyright (C) 2011 The Android Open Source Project +* +* Licensed under the Apache License, Version 2.0 (the "License"); +* you may not use this file except in compliance with the License. +* You may obtain a copy of the License at +* +* http://www.apache.org/licenses/LICENSE-2.0 +* +* Unless required by applicable law or agreed to in writing, software +* distributed under the License is distributed on an "AS IS" BASIS, +* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +* See the License for the specific language governing permissions and +* limitations under the License. +*/ +#ifndef _OBJECT_NAME_MANAGER_H +#define _OBJECT_NAME_MANAGER_H + +#include +#include +#include "SmartPtr.h" + +typedef std::map NamesMap; + +enum NamedObjectType { + VERTEXBUFFER = 0, + TEXTURE = 1, + RENDERBUFFER = 2, + FRAMEBUFFER = 3, + SHADER = 4, + PROGRAM = 5, + NUM_OBJECT_TYPES = 6 // Must be last +}; + +class ObjectData +{ +public: + virtual ~ObjectData() {} +}; +typedef SmartPtr ObjectDataPtr; + +// +// Class NameSpace - this class manages allocations and deletions of objects +// from a single "local" namespace (private to context group). +// For each allocated object name, a "global" name is +// generated as well to be used in the space where all +// contexts are shared. +// +// NOTE: this class does not used by the EGL/GLES layer directly, +// the EGL/GLES layer creates objects using the ShareGroup class +// interface (see below). +class NameSpace +{ + friend class ShareGroup; + friend class GlobalNameSpace; + +private: + explicit NameSpace(NamedObjectType p_type); + ~NameSpace(); + + // + // genName - creates new object in the namespace and returns its name. + // if p_localName is specified this name will be used. + // This function also generate a global name for the object, + // the value of the global name can be retrieved using the + // getGlobalName function. + // + unsigned int genName(unsigned int p_localName = 0, bool genGlobal = true); + + // + // getGlobalName - returns the global name of an object or 0 if the object + // does not exist. + // + unsigned int getGlobalName(unsigned int p_localName); + + // + // deleteName - deletes and object from the namespace as well as its + // global name from the global name space. + // + void deleteName(unsigned int p_localName); + + // + // isObject - returns true if the named object exist. + // + bool isObject(unsigned int p_localName); + + // + // replaces an object to map to an existing global object + // + void replaceGlobalName(unsigned int p_localName, unsigned int p_globalName); + +private: + unsigned int m_nextName; + NamesMap m_localToGlobalMap; + const NamedObjectType m_type; +}; + +// +// class ShareGroup - +// That class manages objects of one "local" context share group, typically +// there will be one inctance of ShareGroup for each user OpenGL context +// unless the user context share with another user context. In that case they +// both will share the same ShareGroup instance. +// calls into that class gets serialized through a lock so it is thread safe. +// +class ShareGroup +{ + friend class ObjectNameManager; + friend class SmartPtr; // to allow destructing when ShareGroupPtr refcount reaches zero + +public: + + // + // genName - generates new object name and returns its name value. + // if p_localName is specified this name will be used. + // This function also generates a "global" name for the object + // which can be queried using the getGlobalName function. + // + unsigned int genName(NamedObjectType p_type, unsigned int p_localName = 0); + + // + // getGlobalName - retrieves the "global" name of an object or 0 if the + // object does not exist. + // + unsigned int getGlobalName(NamedObjectType p_type, unsigned int p_localName); + + // + // deleteName - deletes and object from the namespace as well as its + // global name from the global name space. + // + void deleteName(NamedObjectType p_type, unsigned int p_localName); + + // + // replaceGlobalName - replaces an object to map to an existing global + // named object. (used when creating EGLImage siblings) + // + void replaceGlobalName(NamedObjectType p_type, unsigned int p_localName, unsigned int p_globalName); + + // + // isObject - returns true if the named object exist. + // + bool isObject(NamedObjectType p_type, unsigned int p_localName); + + // + // Assign object global data to a names object + // + void setObjectData(NamedObjectType p_type, unsigned int p_localName, ObjectDataPtr data); + + // + // Retrieve object global data + // + ObjectDataPtr getObjectData(NamedObjectType p_type, unsigned int p_localName); + +private: + ShareGroup(); + ~ShareGroup(); + +private: + mutex_t m_lock; + NameSpace *m_nameSpace[NUM_OBJECT_TYPES]; + void *m_objectsData; +}; + +typedef SmartPtr ShareGroupPtr; +typedef std::multimap ShareGroupsMap; + +// +// ObjectNameManager - +// This class manages the set of all ShareGroups instances, +// each ShareGroup instance can be accessed through one or more 'groupName' +// values. the type of 'groupName' is void *, the intent is that the EGL +// layer will use the user context handle as the name for its ShareGroup +// object. Multiple names can be attached to a ShareGroup object to support +// user context sharing. +// +class ObjectNameManager +{ +public: + ObjectNameManager(); + ~ObjectNameManager(); + + // + // createShareGroup - create a new ShareGroup object and attach it with + // the "name" specified by p_groupName. + // + ShareGroupPtr createShareGroup(void *p_groupName); + + // + // attachShareGroup - find the ShareGroup object attached to the name + // specified in p_existingGroupName and attach p_groupName to the same + // ShareGroup instance. + // + ShareGroupPtr attachShareGroup(void *p_groupName, void *p_existingGroupName); + + // + // getShareGroup - retreive a ShareGroup object based on its "name" + // + ShareGroupPtr getShareGroup(void *p_groupName); + + // + // deleteShareGroup - deletes the attachment of the p_groupName to its + // attached ShareGroup. When the last name of ShareGroup is + // deleted the ShareGroup object is destroyed. + // + void deleteShareGroup(void *p_groupName); + + // + // getGlobalContext() - this function returns a name of an existing + // ShareGroup. The intent is that the EGL layer will + // use that function to get the GL context which each + // new context needs to share with. + // + void *getGlobalContext(); + +private: + ShareGroupsMap m_groups; + mutex_t m_lock; +}; + +#endif