LineageOS/android_development
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

opengles emulator: fix glGetUnifrom

Browse Source 
added state tracking for uniforms in program objects
for each active uniform in index i we will save its starting location
,size and type, so when calling glGetUniform on its location,
we can tell how many bytes we should read from the stream according to
the uniform's type

add some type and size definitions to functions
that calculate size from enum

some other fixes to the codec

Change-Id: I4ecdf41e752454a908d131e76bab113a616f2bc8
This commit is contained in:
Liran
2011-08-01 10:01:54 +03:00
committed by David 'Digit' Turner
parent d2fae7055e
commit 8ee217f9cc
9 changed files with 381 additions and 4 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
tools/emulator/opengl/shared/OpenglCodecCommon/GLClientState.h
View File

@@ -167,6 +167,7 @@ public:
handled = false;
break;
default:
handled = false;
ERR("unknown vertex-attrib parameter param %d\n", param);
}
return handled;

169
tools/emulator/opengl/shared/OpenglCodecCommon/GLSharedGroup.cpp
View File

@@ -10,16 +10,75 @@ BufferData::BufferData(GLsizeiptr size, void * data) : m_size(size)
if (data) memcpy(buffer, data, size);
}
/**** ProgramData ****/
ProgramData::ProgramData() : m_numIndexes(0), m_initialized(false)
{
m_Indexes = NULL;
}
void ProgramData::initProgramData(GLuint numIndexes)
{
m_initialized = true;
m_numIndexes = numIndexes;
delete[] m_Indexes;
m_Indexes = new IndexInfo[numIndexes];
}
bool ProgramData::isInitialized()
{
return m_initialized;
}
ProgramData::~ProgramData()
{
delete[] m_Indexes;
m_Indexes = NULL;
}
void ProgramData::setIndexInfo(GLuint index, GLint base, GLint size, GLenum type)
{
if (index>=m_numIndexes)
return;
m_Indexes[index].base = base;
m_Indexes[index].size = size;
m_Indexes[index].type = type;
}
GLuint ProgramData::getIndexForLocation(GLint location)
{
GLuint i=0;
for (i=0;i<m_numIndexes;++i)
{
GLint low = m_Indexes[i].base;;
GLint high = low + m_Indexes[i].size;
if (location >= low && location < high)
break;
}
return i;
}
GLenum ProgramData::getTypeForLocation(GLint location)
{
GLuint index = getIndexForLocation(location);
if (index<m_numIndexes) {
return m_Indexes[index].type;
}
return 0;
}
/***** GLSharedGroup ****/
GLSharedGroup::GLSharedGroup() :
m_buffers(android::DefaultKeyedVector<GLuint, BufferData*>(NULL))
m_buffers(android::DefaultKeyedVector<GLuint, BufferData*>(NULL)),
m_programs(android::DefaultKeyedVector<GLuint, ProgramData*>(NULL)),
m_shaders(android::List<GLuint>())
{
}
GLSharedGroup::~GLSharedGroup()
{
m_buffers.clear();
m_programs.clear();
}
BufferData * GLSharedGroup::getBufferData(GLuint bufferId)
@@ -56,3 +115,111 @@ void GLSharedGroup::deleteBufferData(GLuint bufferId)
android::AutoMutex _lock(m_lock);
m_buffers.removeItem(bufferId);
}
void GLSharedGroup::addProgramData(GLuint program)
{
android::AutoMutex _lock(m_lock);
ProgramData *pData = m_programs.valueFor(program);
if (pData)
{
m_programs.removeItem(program);
delete pData;
}
m_programs.add(program,new ProgramData());
}
void GLSharedGroup::initProgramData(GLuint program, GLuint numIndexes)
{
android::AutoMutex _lock(m_lock);
ProgramData *pData = m_programs.valueFor(program);
if (pData)
{
pData->initProgramData(numIndexes);
}
}
bool GLSharedGroup::isProgramInitialized(GLuint program)
{
android::AutoMutex _lock(m_lock);
ProgramData* pData = m_programs.valueFor(program);
if (pData)
{
return pData->isInitialized();
}
return false;
}
void GLSharedGroup::deleteProgramData(GLuint program)
{
android::AutoMutex _lock(m_lock);
ProgramData *pData = m_programs.valueFor(program);
if (pData)
delete pData;
m_programs.removeItem(program);
}
void GLSharedGroup::setProgramIndexInfo(GLuint program, GLuint index, GLint base, GLint size, GLenum type)
{
android::AutoMutex _lock(m_lock);
ProgramData* pData = m_programs.valueFor(program);
if (pData)
{
pData->setIndexInfo(index,base,size,type);
}
}
GLenum GLSharedGroup::getProgramUniformType(GLuint program, GLint location)
{
android::AutoMutex _lock(m_lock);
ProgramData* pData = m_programs.valueFor(program);
GLenum type=0;
if (pData)
{
type = pData->getTypeForLocation(location);
}
return type;
}
bool GLSharedGroup::isProgram(GLuint program)
{
android::AutoMutex _lock(m_lock);
ProgramData* pData = m_programs.valueFor(program);
return (pData!=NULL);
}
void GLSharedGroup::addShaderData(GLuint shader)
{
android::AutoMutex _lock(m_lock);
m_shaders.push_front(shader);
}
bool GLSharedGroup::isShader(GLuint shader)
{
android::AutoMutex _lock(m_lock);
android::List<GLuint>::iterator iter;
iter = m_shaders.begin();
while (iter!=m_shaders.end())
{
if (*iter==shader)
return true;
iter++;
}
return false;
}
void GLSharedGroup::deleteShaderData(GLuint shader)
{
android::AutoMutex _lock(m_lock);
android::List<GLuint>::iterator iter;
iter = m_shaders.begin();
while (iter!=m_shaders.end())
{
if (*iter==shader)
{
m_shaders.erase(iter);
return;
}
iter++;
}
}

36
tools/emulator/opengl/shared/OpenglCodecCommon/GLSharedGroup.h
View File

@@ -32,6 +32,7 @@
#include "ErrorLog.h"
#include <utils/KeyedVector.h>
#include <utils/threads.h>
#include <utils/List.h>
#include "FixedBuffer.h"
#include "SmartPtr.h"
@@ -42,10 +43,32 @@ struct BufferData {
FixedBuffer m_fixedBuffer;
};
class ProgramData {
private:
typedef struct _IndexInfo {
GLint base;
GLint size;
GLenum type;
}IndexInfo;
GLuint m_numIndexes;
IndexInfo* m_Indexes;
bool m_initialized;
public:
ProgramData();
void initProgramData(GLuint numIndexes);
bool isInitialized();
virtual ~ProgramData();
void setIndexInfo(GLuint index, GLint base, GLint size, GLenum type);
GLuint getIndexForLocation(GLint location);
GLenum getTypeForLocation(GLint location);
};
class GLSharedGroup {
private:
android::DefaultKeyedVector<GLuint, BufferData*> m_buffers;
android::DefaultKeyedVector<GLuint, ProgramData*> m_programs;
android::List<GLuint> m_shaders;
mutable android::Mutex m_lock;
public:
GLSharedGroup();
@@ -55,6 +78,19 @@ public:
void updateBufferData(GLuint bufferId, GLsizeiptr size, void * data);
GLenum subUpdateBufferData(GLuint bufferId, GLintptr offset, GLsizeiptr size, void * data);
void deleteBufferData(GLuint);
bool isProgram(GLuint program);
bool isProgramInitialized(GLuint program);
void addProgramData(GLuint program);
void initProgramData(GLuint program, GLuint numIndexes);
void deleteProgramData(GLuint program);
void setProgramIndexInfo(GLuint program, GLuint index, GLint base, GLint size, GLenum type);
GLenum getProgramUniformType(GLuint program, GLint location);
void addShaderData(GLuint shader);
bool isShader(GLuint shader);
void deleteShaderData(GLuint shader);
};
typedef SmartPtr<GLSharedGroup> GLSharedGroupPtr;

42
tools/emulator/opengl/shared/OpenglCodecCommon/glUtils.cpp
View File

@@ -30,8 +30,10 @@ size_t glSizeof(GLenum type)
case GL_HALF_FLOAT_OES:
retval = 2;
break;
case GL_INT:
case GL_FLOAT:
case GL_FIXED:
case GL_BOOL:
retval = 4;
break;
#ifdef GL_DOUBLE
@@ -39,6 +41,32 @@ size_t glSizeof(GLenum type)
retval = 8;
break;
#endif
case GL_FLOAT_VEC2:
case GL_INT_VEC2:
case GL_BOOL_VEC2:
retval = 8;
break;
case GL_INT_VEC3:
case GL_BOOL_VEC3:
case GL_FLOAT_VEC3:
retval = 12;
break;
case GL_FLOAT_VEC4:
case GL_BOOL_VEC4:
case GL_INT_VEC4:
case GL_FLOAT_MAT2:
retval = 16;
break;
case GL_FLOAT_MAT3:
retval = 36;
break;
case GL_FLOAT_MAT4:
retval = 64;
break;
case GL_SAMPLER_2D:
case GL_SAMPLER_CUBE:
retval = 4;
break;
default:
ERR("**** ERROR unknown type 0x%x (%s,%d)\n", type, __FUNCTION__,__LINE__);
}
@@ -250,6 +278,7 @@ size_t glUtilsParamSize(GLenum param)
case GL_MAX_TEXTURE_IMAGE_UNITS:
case GL_REQUIRED_TEXTURE_IMAGE_UNITS_OES:
case GL_FRAGMENT_SHADER_DERIVATIVE_HINT_OES:
case GL_LINE_WIDTH:
s = 1;
break;
case GL_ALIASED_LINE_WIDTH_RANGE:
@@ -282,6 +311,7 @@ size_t glUtilsParamSize(GLenum param)
case GL_COLOR_CLEAR_VALUE:
case GL_COLOR_WRITEMASK:
case GL_AMBIENT_AND_DIFFUSE:
case GL_BLEND_COLOR:
s = 4;
break;
case GL_MODELVIEW_MATRIX:
@@ -320,9 +350,12 @@ int glUtilsPixelBitSize(GLenum format, GLenum type)
int componentsize = 0;
int pixelsize = 0;
switch(type) {
case GL_BYTE:
case GL_UNSIGNED_BYTE:
componentsize = 8;
break;
case GL_SHORT:
case GL_UNSIGNED_SHORT:
case GL_UNSIGNED_SHORT_5_6_5:
case GL_UNSIGNED_SHORT_4_4_4_4:
case GL_UNSIGNED_SHORT_5_5_5_1:
@@ -331,6 +364,13 @@ int glUtilsPixelBitSize(GLenum format, GLenum type)
case GL_RGBA4_OES:
pixelsize = 16;
break;
case GL_INT:
case GL_UNSIGNED_INT:
case GL_FLOAT:
case GL_FIXED:
case GL_UNSIGNED_INT_24_8_OES:
pixelsize = 32;
break;
default:
ERR("glUtilsPixelBitSize: unknown pixel type - assuming pixel data 0\n");
componentsize = 0;
@@ -345,6 +385,8 @@ int glUtilsPixelBitSize(GLenum format, GLenum type)
#endif
case GL_ALPHA:
case GL_LUMINANCE:
case GL_DEPTH_COMPONENT:
case GL_DEPTH_STENCIL_OES:
components = 1;
break;
case GL_LUMINANCE_ALPHA:

90
tools/emulator/opengl/system/GLESv2_enc/GL2Encoder.cpp
View File

@@ -47,6 +47,13 @@ GL2Encoder::GL2Encoder(IOStream *stream) : gl2_encoder_context_t(stream)
set_glShaderSource(s_glShaderSource);
set_glFinish(s_glFinish);
m_glGetError_enc = set_glGetError(s_glGetError);
m_glLinkProgram_enc = set_glLinkProgram(s_glLinkProgram);
m_glDeleteProgram_enc = set_glDeleteProgram(s_glDeleteProgram);
m_glGetUniformiv_enc = set_glGetUniformiv(s_glGetUniformiv);
m_glGetUniformfv_enc = set_glGetUniformfv(s_glGetUniformfv);
m_glCreateProgram_enc = set_glCreateProgram(s_glCreateProgram);
m_glCreateShader_enc = set_glCreateShader(s_glCreateShader);
m_glDeleteShader_enc = set_glDeleteShader(s_glDeleteShader);
}
GL2Encoder::~GL2Encoder()
@@ -416,3 +423,86 @@ void GL2Encoder::s_glFinish(void *self)
ctx->glFinishRoundTrip(self);
}
void GL2Encoder::s_glLinkProgram(void * self, GLuint program)
{
GL2Encoder *ctx = (GL2Encoder *)self;
ctx->m_glLinkProgram_enc(self, program);
GLint linkStatus = 0;
ctx->glGetProgramiv(self,program,GL_LINK_STATUS,&linkStatus);
if (!linkStatus)
return;
//get number of active uniforms in the program
GLint numUniforms=0;
ctx->glGetProgramiv(self, program, GL_ACTIVE_UNIFORMS, &numUniforms);
ctx->m_shared->initProgramData(program,numUniforms);
//get the length of the longest uniform name
GLint maxLength=0;
ctx->glGetProgramiv(self, program, GL_ACTIVE_UNIFORM_MAX_LENGTH, &maxLength);
GLint size;
GLenum type;
GLchar *name = new GLchar[maxLength+1];
GLint location;
//for each active uniform, get its size and starting location.
for (GLint i=0 ; i<numUniforms ; ++i)
{
ctx->glGetActiveUniform(self, program, i, maxLength, NULL, &size, &type, name);
location = ctx->glGetUniformLocation(self, program, name);
ctx->m_shared->setProgramIndexInfo(program, i, location, size, type);
}
delete[] name;
}
void GL2Encoder::s_glDeleteProgram(void *self, GLuint program)
{
GL2Encoder *ctx = (GL2Encoder*)self;
ctx->m_glDeleteProgram_enc(self, program);
ctx->m_shared->deleteProgramData(program);
}
void GL2Encoder::s_glGetUniformiv(void *self, GLuint program, GLint location, GLint* params)
{
GL2Encoder *ctx = (GL2Encoder*)self;
SET_ERROR_IF(!(ctx->m_shared->isProgram(program) || ctx->m_shared->isShader(program)), GL_INVALID_VALUE);
SET_ERROR_IF(!ctx->m_shared->isProgramInitialized(program), GL_INVALID_OPERATION);
SET_ERROR_IF(ctx->m_shared->getProgramUniformType(program,location)==0, GL_INVALID_OPERATION);
ctx->m_glGetUniformiv_enc(self, program, location, params);
}
void GL2Encoder::s_glGetUniformfv(void *self, GLuint program, GLint location, GLfloat* params)
{
GL2Encoder *ctx = (GL2Encoder*)self;
SET_ERROR_IF(!(ctx->m_shared->isProgram(program) || ctx->m_shared->isShader(program)), GL_INVALID_VALUE);
SET_ERROR_IF(!ctx->m_shared->isProgramInitialized(program), GL_INVALID_OPERATION);
SET_ERROR_IF(ctx->m_shared->getProgramUniformType(program,location)==0, GL_INVALID_OPERATION);
ctx->m_glGetUniformfv_enc(self, program, location, params);
}
GLuint GL2Encoder::s_glCreateProgram(void * self)
{
GL2Encoder *ctx = (GL2Encoder*)self;
GLuint program = ctx->m_glCreateProgram_enc(self);
if (program!=0)
ctx->m_shared->addProgramData(program);
return program;
}
GLuint GL2Encoder::s_glCreateShader(void *self, GLenum shaderType)
{
GL2Encoder *ctx = (GL2Encoder*)self;
GLuint shader = ctx->m_glCreateShader_enc(self, shaderType);
if (shader!=0)
ctx->m_shared->addShaderData(shader);
return shader;
}
void GL2Encoder::s_glDeleteShader(void *self, GLenum shader)
{
GL2Encoder *ctx = (GL2Encoder*)self;
ctx->m_glDeleteShader_enc(self,shader);
ctx->m_shared->deleteShaderData(shader);
}

23
tools/emulator/opengl/system/GLESv2_enc/GL2Encoder.h
View File

@@ -32,6 +32,7 @@ public:
}
void setSharedGroup(GLSharedGroupPtr shared){ m_shared = shared; }
const GLClientState *state() { return m_state; }
const GLSharedGroupPtr shared() { return m_shared; }
void flush() {
gl2_encoder_context_t::m_stream->flush();
}
@@ -118,5 +119,27 @@ private:
static void s_glShaderSource(void *self, GLuint shader, GLsizei count, const GLchar **string, const GLint *length);
static void s_glFinish(void *self);
glLinkProgram_client_proc_t m_glLinkProgram_enc;
static void s_glLinkProgram(void *self, GLuint program);
glDeleteProgram_client_proc_t m_glDeleteProgram_enc;
static void s_glDeleteProgram(void * self, GLuint program);
glGetUniformiv_client_proc_t m_glGetUniformiv_enc;
static void s_glGetUniformiv(void *self, GLuint program, GLint location , GLint *params);
glGetUniformfv_client_proc_t m_glGetUniformfv_enc;
static void s_glGetUniformfv(void *self, GLuint program, GLint location , GLfloat *params);
glCreateProgram_client_proc_t m_glCreateProgram_enc;
static GLuint s_glCreateProgram(void *self);
glCreateShader_client_proc_t m_glCreateShader_enc;
static GLuint s_glCreateShader(void *self, GLenum shaderType);
glDeleteShader_client_proc_t m_glDeleteShader_enc;
static void s_glDeleteShader(void *self, GLuint shader);
};
#endif

7
tools/emulator/opengl/system/GLESv2_enc/GL2EncoderUtils.cpp
View File

@@ -30,3 +30,10 @@ size_t pixelDataSize3D(void *self, GLsizei width, GLsizei height, GLsizei depth,
size_t layerSize = pixelDataSize(self, width, height, format, type, pack);
return layerSize * depth;
}
GLenum uniformType(void * self, GLuint program, GLint location)
{
GL2Encoder * ctx = (GL2Encoder *) self;
assert (ctx->shared() != NULL);
return ctx->shared()->getProgramUniformType(program, location);
}

1
tools/emulator/opengl/system/GLESv2_enc/GL2EncoderUtils.h
View File

@@ -19,5 +19,6 @@
extern "C" {
size_t pixelDataSize(void *self, GLsizei width, GLsizei height, GLenum format, GLenum type, int pack);
size_t pixelDataSize3D(void *self, GLsizei width, GLsizei height, GLsizei depth, GLenum format, GLenum type, int pack);
GLenum uniformType(void * self, GLuint program, GLint location);
};
#endif

16
tools/emulator/opengl/system/GLESv2_enc/gl2.attrib
View File

@@ -76,8 +76,10 @@ glGenTextures
glGetActiveAttrib
len name bufsize
dir name out
var_flag name nullAllowed
dir length out
len length (sizeof(GLsizei))
var_flag length nullAllowed
dir size out
len size (sizeof(GLint))
dir type out
@@ -87,8 +89,10 @@ glGetActiveAttrib
glGetActiveUniform
len name bufsize
dir name out
var_flag name nullAllowed
dir length out
len length (sizeof(GLsizei))
var_flag length nullAllowed
dir size out
len size (sizeof(GLint))
dir type out
@@ -168,7 +172,9 @@ glGetShaderInfoLog
#void glGetShaderPrecisionFormat(GLenum shadertype, GLenum precisiontype, GLint *range, GLint *precision)
glGetShaderPrecisionFormat
len range (sizeof(GLint))
dir range out
len range (2 * sizeof(GLint))
dir precision out
len precision (sizeof(GLint))
#void glGetShaderSource(GLuint shader, GLsizei bufsize, GLsizei *length, GLchar *source)
@@ -195,11 +201,13 @@ glGetTexParameteriv
#void glGetUniformfv(GLuint program, GLint location, GLfloat *params)
glGetUniformfv
flag unsupported
dir params out
len params glSizeof(uniformType(self, program, location))
#void glGetUniformiv(GLuint program, GLint location, GLint *params)
glGetUniformiv
flag unsupported
dir params out
len params glSizeof(uniformType(self, program, location))
#int glGetUniformLocation(GLuint program, GLchar *name)
glGetUniformLocation
@@ -210,11 +218,13 @@ glGetUniformLocation
# thus we still need to implement it.
#void glGetVertexAttribfv(GLuint index, GLenum pname, GLfloat *params)
glGetVertexAttribfv
dir params out
len params (glUtilsParamSize(pname) * sizeof(GLfloat))
#see glGetVertexAttribfv for comments
#void glGetVertexAttribiv(GLuint index, GLenum pname, GLint *params)
glGetVertexAttribiv
dir params out
len params (glUtilsParamSize(pname) * sizeof(GLint))