GLSharedGroup.cpp revision 2ec2fa1a687390c22492fa6344e45d4c6b3c0ea7 
1#include "GLSharedGroup.h"
2
3/**** BufferData ****/
4
5BufferData::BufferData() : m_size(0) {};
6BufferData::BufferData(GLsizeiptr size, void * data) : m_size(size)
7{
8    void * buffer = NULL;
9    if (size>0) buffer = m_fixedBuffer.alloc(size);
10    if (data) memcpy(buffer, data, size);
11}
12
13/**** ProgramData ****/
14ProgramData::ProgramData() : m_numIndexes(0),
15                             m_initialized(false),
16                             m_locShiftWAR(false)
17{
18    m_Indexes = NULL;
19}
20
21void ProgramData::initProgramData(GLuint numIndexes)
22{
23    m_initialized = true;
24    m_numIndexes = numIndexes;
25    delete[] m_Indexes;
26    m_Indexes = new IndexInfo[numIndexes];
27    m_locShiftWAR = false;
28}
29
30bool ProgramData::isInitialized()
31{
32    return m_initialized;
33}
34
35ProgramData::~ProgramData()
36{
37    delete[] m_Indexes;
38    m_Indexes = NULL;
39}
40
41void ProgramData::setIndexInfo(GLuint index, GLint base, GLint size, GLenum type)
42{
43    if (index>=m_numIndexes)
44        return;
45    m_Indexes[index].base = base;
46    m_Indexes[index].size = size;
47    m_Indexes[index].type = type;
48}
49
50GLuint ProgramData::getIndexForLocation(GLint location)
51{
52    GLuint i=0;
53    for (i=0;i<m_numIndexes;++i)
54    {
55        GLint low = m_Indexes[i].base;;
56        GLint high = low + m_Indexes[i].size;
57        if (location >= low && location < high)
58            break;
59    }
60    return i;
61}
62
63GLenum ProgramData::getTypeForLocation(GLint location)
64{
65    GLuint index = getIndexForLocation(location);
66    if (index<m_numIndexes) {
67        return m_Indexes[index].type;
68    }
69    return 0;
70}
71
72void ProgramData::setupLocationShiftWAR()
73{
74    m_locShiftWAR = false;
75    for (int i=0; i<m_numIndexes; i++) {
76        if (0 != (m_Indexes[i].base & 0xffff)) {
77            return;
78        }
79    }
80    m_locShiftWAR = true;
81}
82
83GLint ProgramData::locationWARHostToApp(GLint hostLoc)
84{
85    if (m_locShiftWAR && hostLoc>0) return hostLoc>>16;
86    else return hostLoc;
87}
88
89GLint ProgramData::locationWARAppToHost(GLint appLoc)
90{
91    if (m_locShiftWAR && appLoc>0) return appLoc<<16;
92    else return appLoc;
93}
94
95
96/***** GLSharedGroup ****/
97
98GLSharedGroup::GLSharedGroup() :
99    m_buffers(android::DefaultKeyedVector<GLuint, BufferData*>(NULL)),
100    m_programs(android::DefaultKeyedVector<GLuint, ProgramData*>(NULL)),
101    m_shaders(android::List<GLuint>())
102{
103}
104
105GLSharedGroup::~GLSharedGroup()
106{
107    m_buffers.clear();
108    m_programs.clear();
109}
110
111BufferData * GLSharedGroup::getBufferData(GLuint bufferId)
112{
113    android::AutoMutex _lock(m_lock);
114    return m_buffers.valueFor(bufferId);
115}
116
117void GLSharedGroup::addBufferData(GLuint bufferId, GLsizeiptr size, void * data)
118{
119    android::AutoMutex _lock(m_lock);
120    m_buffers.add(bufferId, new BufferData(size, data));
121}
122
123void GLSharedGroup::updateBufferData(GLuint bufferId, GLsizeiptr size, void * data)
124{
125    android::AutoMutex _lock(m_lock);
126    m_buffers.replaceValueFor(bufferId, new BufferData(size, data));
127}
128
129GLenum GLSharedGroup::subUpdateBufferData(GLuint bufferId, GLintptr offset, GLsizeiptr size, void * data)
130{
131    android::AutoMutex _lock(m_lock);
132    BufferData * buf = m_buffers.valueFor(bufferId);
133    if ((!buf) || (buf->m_size < offset+size) || (offset < 0) || (size<0)) return GL_INVALID_VALUE;
134
135    //it's safe to update now
136    memcpy((char*)buf->m_fixedBuffer.ptr() + offset, data, size);
137    return GL_NO_ERROR;
138}
139
140void GLSharedGroup::deleteBufferData(GLuint bufferId)
141{
142    android::AutoMutex _lock(m_lock);
143    m_buffers.removeItem(bufferId);
144}
145
146void GLSharedGroup::addProgramData(GLuint program)
147{
148    android::AutoMutex _lock(m_lock);
149    ProgramData *pData = m_programs.valueFor(program);
150    if (pData)
151    {
152        m_programs.removeItem(program);
153        delete pData;
154    }
155
156    m_programs.add(program,new ProgramData());
157}
158
159void GLSharedGroup::initProgramData(GLuint program, GLuint numIndexes)
160{
161    android::AutoMutex _lock(m_lock);
162    ProgramData *pData = m_programs.valueFor(program);
163    if (pData)
164    {
165        pData->initProgramData(numIndexes);
166    }
167}
168
169bool GLSharedGroup::isProgramInitialized(GLuint program)
170{
171    android::AutoMutex _lock(m_lock);
172    ProgramData* pData = m_programs.valueFor(program);
173    if (pData)
174    {
175        return pData->isInitialized();
176    }
177    return false;
178}
179
180void GLSharedGroup::deleteProgramData(GLuint program)
181{
182    android::AutoMutex _lock(m_lock);
183    ProgramData *pData = m_programs.valueFor(program);
184    if (pData)
185        delete pData;
186    m_programs.removeItem(program);
187}
188
189void GLSharedGroup::setProgramIndexInfo(GLuint program, GLuint index, GLint base, GLint size, GLenum type)
190{
191    android::AutoMutex _lock(m_lock);
192    ProgramData* pData = m_programs.valueFor(program);
193    if (pData)
194    {
195        pData->setIndexInfo(index,base,size,type);
196    }
197}
198
199GLenum GLSharedGroup::getProgramUniformType(GLuint program, GLint location)
200{
201    android::AutoMutex _lock(m_lock);
202    ProgramData* pData = m_programs.valueFor(program);
203    GLenum type=0;
204    if (pData)
205    {
206        type = pData->getTypeForLocation(location);
207    }
208    return type;
209}
210
211bool  GLSharedGroup::isProgram(GLuint program)
212{
213    android::AutoMutex _lock(m_lock);
214    ProgramData* pData = m_programs.valueFor(program);
215    return (pData!=NULL);
216}
217
218void GLSharedGroup::setupLocationShiftWAR(GLuint program)
219{
220    android::AutoMutex _lock(m_lock);
221    ProgramData* pData = m_programs.valueFor(program);
222    if (pData) pData->setupLocationShiftWAR();
223}
224
225GLint GLSharedGroup::locationWARHostToApp(GLuint program, GLint hostLoc)
226{
227    android::AutoMutex _lock(m_lock);
228    ProgramData* pData = m_programs.valueFor(program);
229    if (pData) return pData->locationWARHostToApp(hostLoc);
230    else return hostLoc;
231}
232
233GLint GLSharedGroup::locationWARAppToHost(GLuint program, GLint appLoc)
234{
235    android::AutoMutex _lock(m_lock);
236    ProgramData* pData = m_programs.valueFor(program);
237    if (pData) return pData->locationWARAppToHost(appLoc);
238    else return appLoc;
239}
240
241
242void  GLSharedGroup::addShaderData(GLuint shader)
243{
244    android::AutoMutex _lock(m_lock);
245    m_shaders.push_front(shader);
246
247}
248bool  GLSharedGroup::isShader(GLuint shader)
249{
250    android::AutoMutex _lock(m_lock);
251    android::List<GLuint>::iterator iter;
252    iter = m_shaders.begin();
253    while (iter!=m_shaders.end())
254    {
255        if (*iter==shader)
256            return true;
257        iter++;
258    }
259    return false;
260}
261void  GLSharedGroup::deleteShaderData(GLuint shader)
262{
263    android::AutoMutex _lock(m_lock);
264    android::List<GLuint>::iterator iter;
265    iter = m_shaders.begin();
266    while (iter!=m_shaders.end())
267    {
268        if (*iter==shader)
269        {
270            m_shaders.erase(iter);
271            return;
272        }
273        iter++;
274    }
275}
276