swung0x48/MobileGL
1
0
Fork 0
mirror of https://github.com/MobileGL-Dev/MobileGL synced 2026-09-11 13:48:30 +09:00
Code Issues Packages Projects Releases Wiki Activity

[Misc] (All): Run format_code.sh

Browse Source
This commit is contained in:
BZLZHH
2025-10-02 15:11:38 +08:00
parent 69fe996e15
commit ee971306ca
26 changed files with 1355 additions and 1492 deletions
Download Patch File Download Diff File Expand all files Collapse all files
MobileGL/Defines.h
+1 -1
View File
@@ -6,7 +6,7 @@
#endif #endif
#ifdef _WIN32 #ifdef _WIN32
# ifndef NOMINMAX #ifndef NOMINMAX
#define NOMINMAX 1 // prevent Windows.h from defining min and max macros #define NOMINMAX 1 // prevent Windows.h from defining min and max macros
#endif #endif
#endif #endif
MobileGL/MG_Backend/Backends.h
+35 -32
View File
@@ -7,16 +7,17 @@ namespace MobileGL {
namespace MG_Backend { namespace MG_Backend {
namespace Unknown { namespace Unknown {
const RendererInfo RendererInfoUnknown = { const RendererInfo RendererInfoUnknown = {
"<unknown renderer of MobileGL>", // Renderer Name "<unknown renderer of MobileGL>", // Renderer Name
"<unknown backend>", // Backend Name "<unknown backend>", // Backend Name
", <unknown>", // Extra vendor ", <unknown>", // Extra vendor
{ // OpenGL Info {
{3, 3, 0}, // Target OpenGL Version // OpenGL Info
{4, 6, 0}, // Target Shading Language Version {3, 3, 0}, // Target OpenGL Version
{ }, // OpenGL Extensions {4, 6, 0}, // Target Shading Language Version
false // Is Compatibility Profile {}, // OpenGL Extensions
}, false // Is Compatibility Profile
{ } // Backend Capability },
{} // Backend Capability
}; };
} }
@@ -27,31 +28,33 @@ namespace MobileGL {
}; };
const RendererInfo RendererInfoVulkan = { const RendererInfo RendererInfoVulkan = {
"MobileGlued-vk", // Renderer Name "MobileGlued-vk", // Renderer Name
"Diligent Engine (Vulkan)", // Backend Name "Diligent Engine (Vulkan)", // Backend Name
Nullopt, // Extra vendor Nullopt, // Extra vendor
{ // OpenGL Info {
{3, 3, 0}, // Target OpenGL Version // OpenGL Info
{4, 6, 0}, // Target Shading Language Version {3, 3, 0}, // Target OpenGL Version
{V_OpenGL30, V_OpenGL31, V_OpenGL32, // OpenGL Extensions {4, 6, 0}, // Target Shading Language Version
V_OpenGL33}, {V_OpenGL30, V_OpenGL31, V_OpenGL32, // OpenGL Extensions
false // Is Compatibility Profile V_OpenGL33},
}, false // Is Compatibility Profile
{ } // Backend Capability },
{} // Backend Capability
}; };
const RendererInfo RendererInfoMetal = { const RendererInfo RendererInfoMetal = {
"MobileGlued-mtl", // Renderer Name "MobileGlued-mtl", // Renderer Name
"Diligent Engine (Metal)", // Backend Name "Diligent Engine (Metal)", // Backend Name
Nullopt, // Extra vendor Nullopt, // Extra vendor
{ // OpenGL Info {
{3, 3, 0}, // Target OpenGL Version // OpenGL Info
{4, 6, 0}, // Target Shading Language Version {3, 3, 0}, // Target OpenGL Version
{V_OpenGL30, V_OpenGL31, V_OpenGL32, // OpenGL Extensions {4, 6, 0}, // Target Shading Language Version
V_OpenGL33}, {V_OpenGL30, V_OpenGL31, V_OpenGL32, // OpenGL Extensions
false // Is Compatibility Profile V_OpenGL33},
}, false // Is Compatibility Profile
{ } // Backend Capability },
{} // Backend Capability
}; };
} // namespace Diligent } // namespace Diligent
MobileGL/MG_Benchmark/Program/ProgramBench.cpp
+7 -8
View File
@@ -92,11 +92,11 @@ static void BM_CompileVertexShader(benchmark::State& state) {
GLuint vs = CreateShader(GL_VERTEX_SHADER); GLuint vs = CreateShader(GL_VERTEX_SHADER);
ShaderSource(vs, 1, &vsSrc, NULL); ShaderSource(vs, 1, &vsSrc, NULL);
CompileShader(vs); CompileShader(vs);
// Cleanup // Cleanup
DeleteShader(vs); DeleteShader(vs);
} }
// Set the counter for Compiles/Second // Set the counter for Compiles/Second
state.counters["VS_Compiles/Second"] = state.iterations(); state.counters["VS_Compiles/Second"] = state.iterations();
state.counters["VS_Bytes/Second"] = state.iterations() * vsLen; state.counters["VS_Bytes/Second"] = state.iterations() * vsLen;
@@ -117,11 +117,11 @@ static void BM_CompileFragmentShader(benchmark::State& state) {
GLuint fs = CreateShader(GL_FRAGMENT_SHADER); GLuint fs = CreateShader(GL_FRAGMENT_SHADER);
ShaderSource(fs, 1, &fsSrc, NULL); ShaderSource(fs, 1, &fsSrc, NULL);
CompileShader(fs); CompileShader(fs);
// Cleanup // Cleanup
DeleteShader(fs); DeleteShader(fs);
} }
// Set the counter for Compiles/Second // Set the counter for Compiles/Second
state.counters["FS_Compiles/Second"] = state.iterations(); state.counters["FS_Compiles/Second"] = state.iterations();
state.counters["FS_Bytes/Second"] = state.iterations() * fsLen; state.counters["FS_Bytes/Second"] = state.iterations() * fsLen;
@@ -142,17 +142,17 @@ static void BM_CompileBothShaders(benchmark::State& state) {
GLuint vs = CreateShader(GL_VERTEX_SHADER); GLuint vs = CreateShader(GL_VERTEX_SHADER);
ShaderSource(vs, 1, &vsSrc, NULL); ShaderSource(vs, 1, &vsSrc, NULL);
CompileShader(vs); CompileShader(vs);
// Create and compile fragment shader // Create and compile fragment shader
GLuint fs = CreateShader(GL_FRAGMENT_SHADER); GLuint fs = CreateShader(GL_FRAGMENT_SHADER);
ShaderSource(fs, 1, &fsSrc, NULL); ShaderSource(fs, 1, &fsSrc, NULL);
CompileShader(fs); CompileShader(fs);
// Cleanup // Cleanup
DeleteShader(vs); DeleteShader(vs);
DeleteShader(fs); DeleteShader(fs);
} }
// Set the counter for Compiles/Second // Set the counter for Compiles/Second
state.counters["VS_Compiles/Second"] = state.iterations(); state.counters["VS_Compiles/Second"] = state.iterations();
state.counters["FS_Compiles/Second"] = state.iterations(); state.counters["FS_Compiles/Second"] = state.iterations();
@@ -227,7 +227,6 @@ static void BM_CompileAndLink(benchmark::State& state) {
DeleteShader(fs); DeleteShader(fs);
} }
// Set the counter for Compiles/Second // Set the counter for Compiles/Second
state.counters["VS_Compiles/Second"] = state.iterations(); state.counters["VS_Compiles/Second"] = state.iterations();
state.counters["FS_Compiles/Second"] = state.iterations(); state.counters["FS_Compiles/Second"] = state.iterations();
MobileGL/MG_Benchmark/SanityBench.cpp
+4 -7
View File
@@ -10,11 +10,9 @@ static void Sanity_VectorResize(benchmark::State& state) {
v[i] = i; v[i] = i;
} }
} }
state.SetBytesProcessed(int64_t(state.iterations()) * state.SetBytesProcessed(int64_t(state.iterations()) * int64_t(state.range(0)));
int64_t(state.range(0)));
} }
BENCHMARK(Sanity_VectorResize)->Arg(2<<5)->Arg(2<<10)->Arg(2<<20); BENCHMARK(Sanity_VectorResize)->Arg(2 << 5)->Arg(2 << 10)->Arg(2 << 20);
static void Sanity_memcpy(benchmark::State& state) { static void Sanity_memcpy(benchmark::State& state) {
char* src = new char[state.range(0)]; char* src = new char[state.range(0)];
@@ -22,11 +20,10 @@ static void Sanity_memcpy(benchmark::State& state) {
memset(src, 'x', state.range(0)); memset(src, 'x', state.range(0));
for (auto _ : state) for (auto _ : state)
memcpy(dst, src, state.range(0)); memcpy(dst, src, state.range(0));
state.SetBytesProcessed(int64_t(state.iterations()) * state.SetBytesProcessed(int64_t(state.iterations()) * int64_t(state.range(0)));
int64_t(state.range(0)));
delete[] src; delete[] src;
delete[] dst; delete[] dst;
} }
BENCHMARK(Sanity_memcpy)->Range(8, 8<<10); BENCHMARK(Sanity_memcpy)->Range(8, 8 << 10);
BENCHMARK_MAIN(); BENCHMARK_MAIN();
MobileGL/MG_Impl/GLImpl/Program/GL_Program.cpp
+180 -221
View File
@@ -17,15 +17,13 @@ namespace MobileGL {
} }
static SharedPtr<MG_State::GLState::ShaderObject> TryToGetShaderObject(Uint shader) { static SharedPtr<MG_State::GLState::ShaderObject> TryToGetShaderObject(Uint shader) {
if (!CheckShaderNameValidity(shader)) if (!CheckShaderNameValidity(shader)) return nullptr;
return nullptr;
auto shaderObject = MG_State::pGLContext->GetShaderObject(shader); auto shaderObject = MG_State::pGLContext->GetShaderObject(shader);
if (!shaderObject) { if (!shaderObject) {
MG_State::pGLContext->RecordError( MG_State::pGLContext->RecordError(
ErrorCode::InvalidOperation, ErrorCode::InvalidOperation,
MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "`shader` is not a shader object."));
"`shader` is not a shader object."));
return nullptr; return nullptr;
} }
return shaderObject; return shaderObject;
@@ -43,24 +41,21 @@ namespace MobileGL {
} }
static SharedPtr<MG_State::GLState::ProgramObject> TryToGetProgramObject(GLuint program) { static SharedPtr<MG_State::GLState::ProgramObject> TryToGetProgramObject(GLuint program) {
if (!CheckProgramNameValidity(program)) if (!CheckProgramNameValidity(program)) return nullptr;
return nullptr;
auto programObject = MG_State::pGLContext->GetProgramObject(program); auto programObject = MG_State::pGLContext->GetProgramObject(program);
if (!programObject) { if (!programObject) {
MG_State::pGLContext->RecordError( MG_State::pGLContext->RecordError(
ErrorCode::InvalidOperation, ErrorCode::InvalidOperation,
MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "`program` is not a program object."));
"`program` is not a program object."));
return nullptr; return nullptr;
} }
return programObject; return programObject;
} }
void CopyStr(GLsizei bufSize, GLsizei *length, GLchar *dst, const char* src, GLsizei srcLength) { void CopyStr(GLsizei bufSize, GLsizei* length, GLchar* dst, const char* src, GLsizei srcLength) {
auto sz = std::min(bufSize - 1, srcLength); auto sz = std::min(bufSize - 1, srcLength);
if (length) if (length) *length = sz;
*length = sz;
if (bufSize == 0) return; if (bufSize == 0) return;
@@ -70,11 +65,9 @@ namespace MobileGL {
void AttachShader_State(GLuint program, GLuint shader) { void AttachShader_State(GLuint program, GLuint shader) {
auto programObject = TryToGetProgramObject(program); auto programObject = TryToGetProgramObject(program);
if (!programObject) if (!programObject) return;
return;
auto shaderObject = TryToGetShaderObject(shader); auto shaderObject = TryToGetShaderObject(shader);
if (!shaderObject) if (!shaderObject) return;
return;
if (!programObject->AttachShader(shaderObject)) { if (!programObject->AttachShader(shaderObject)) {
MG_State::pGLContext->RecordError( MG_State::pGLContext->RecordError(
ErrorCode::InvalidOperation, ErrorCode::InvalidOperation,
@@ -87,31 +80,29 @@ namespace MobileGL {
void BindAttribLocation_State(GLuint program, GLuint index, const GLchar* name) { void BindAttribLocation_State(GLuint program, GLuint index, const GLchar* name) {
if (index >= MG_State::GLState::VertexArrayObject::MAX_VERTEX_ATTRIBS) { if (index >= MG_State::GLState::VertexArrayObject::MAX_VERTEX_ATTRIBS) {
MG_State::pGLContext->RecordError( MG_State::pGLContext->RecordError(
ErrorCode::InvalidValue, ErrorCode::InvalidValue,
MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
"`index` is greater than or equal to `GL_MAX_VERTEX_ATTRIBS`.")); "`index` is greater than or equal to `GL_MAX_VERTEX_ATTRIBS`."));
return; return;
} }
if (strncmp(name, "gl_", 3) == 0) { if (strncmp(name, "gl_", 3) == 0) {
MG_State::pGLContext->RecordError( MG_State::pGLContext->RecordError(
ErrorCode::InvalidOperation, ErrorCode::InvalidOperation,
MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
"`name` starts with the reserved prefix `gl_`.")); "`name` starts with the reserved prefix `gl_`."));
return; return;
} }
auto programObject = TryToGetProgramObject(program); auto programObject = TryToGetProgramObject(program);
if (!programObject) if (!programObject) return;
return;
programObject->SetExplicitAttribLocation(index, name); programObject->SetExplicitAttribLocation(index, name);
} }
void CompileShader_State(GLuint shader) { void CompileShader_State(GLuint shader) {
auto shaderObject = TryToGetShaderObject(shader); auto shaderObject = TryToGetShaderObject(shader);
if (!shaderObject) if (!shaderObject) return;
return;
shaderObject->Compile(); shaderObject->Compile();
} }
@@ -120,43 +111,38 @@ namespace MobileGL {
} }
GLuint CreateShader_State(GLenum type) { GLuint CreateShader_State(GLenum type) {
auto shaderId = MG_State::pGLContext->CreateShader(MG_State::GLState::ConvertMGLShaderStageByGLShaderType(type)); auto shaderId =
MG_State::pGLContext->CreateShader(MG_State::GLState::ConvertMGLShaderStageByGLShaderType(type));
if (shaderId == 0) { if (shaderId == 0) {
MG_State::pGLContext->RecordError( MG_State::pGLContext->RecordError(
ErrorCode::InvalidValue, ErrorCode::InvalidValue,
MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "`shaderType` is not an accepted value."));
"`shaderType` is not an accepted value."));
return 0; return 0;
} }
return shaderId; return shaderId;
} }
void DeleteProgram_State(GLuint program) { void DeleteProgram_State(GLuint program) {
if (!CheckProgramNameValidity(program)) if (!CheckProgramNameValidity(program)) return;
return;
MG_State::pGLContext->MarkProgramForDeletion(program); MG_State::pGLContext->MarkProgramForDeletion(program);
} }
void DeleteShader_State(GLuint shader) { void DeleteShader_State(GLuint shader) {
if (!CheckProgramNameValidity(shader)) if (!CheckProgramNameValidity(shader)) return;
return;
MG_State::pGLContext->MarkShaderForDeletion(shader); MG_State::pGLContext->MarkShaderForDeletion(shader);
} }
void DetachShader_State(GLuint program, GLuint shader) { void DetachShader_State(GLuint program, GLuint shader) {
auto shaderObject = TryToGetShaderObject(shader); auto shaderObject = TryToGetShaderObject(shader);
if (!shaderObject) if (!shaderObject) return;
return;
auto programObject = TryToGetProgramObject(program); auto programObject = TryToGetProgramObject(program);
if (!programObject) if (!programObject) return;
return;
auto count = programObject->DetachShader(shaderObject); auto count = programObject->DetachShader(shaderObject);
if (count <= 0) { if (count <= 0) {
MG_State::pGLContext->RecordError( MG_State::pGLContext->RecordError(
ErrorCode::InvalidOperation, ErrorCode::InvalidOperation,
MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "Shader is not attached to program."));
"Shader is not attached to program."));
return; return;
} }
} }
@@ -165,24 +151,22 @@ namespace MobileGL {
GLenum* type, GLchar* name) { GLenum* type, GLchar* name) {
if (bufSize < 0) { if (bufSize < 0) {
MG_State::pGLContext->RecordError( MG_State::pGLContext->RecordError(
ErrorCode::InvalidValue, ErrorCode::InvalidValue,
MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "`bufSize` is less than 0."));
"`bufSize` is less than 0."));
return; return;
} }
auto programObject = TryToGetProgramObject(program); auto programObject = TryToGetProgramObject(program);
if (!programObject) if (!programObject) return;
return;
auto attribCount = programObject->GetActiveAttributesCount(); auto attribCount = programObject->GetActiveAttributesCount();
if (index >= attribCount) { if (index >= attribCount) {
MG_State::pGLContext->RecordError( MG_State::pGLContext->RecordError(
ErrorCode::InvalidValue, ErrorCode::InvalidValue,
MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, MakeShared<GenericErrorInfo>(
"`index` is greater than or equal to the number of active attribute variables in `program`.")); "MG_Impl/GLImpl", __func__,
"`index` is greater than or equal to the number of active attribute variables in `program`."));
return; return;
} }
if (type != nullptr) if (type != nullptr) *type = programObject->GetAttribType(index);
*type = programObject->GetAttribType(index);
if (bufSize == 0) return; if (bufSize == 0) return;
auto& attribName = programObject->GetAttribName(index); auto& attribName = programObject->GetAttribName(index);
CopyStr(bufSize, length, name, attribName.c_str(), attribName.length()); CopyStr(bufSize, length, name, attribName.c_str(), attribName.length());
@@ -192,25 +176,23 @@ namespace MobileGL {
GLenum* type, GLchar* name) { GLenum* type, GLchar* name) {
if (bufSize < 0) { if (bufSize < 0) {
MG_State::pGLContext->RecordError( MG_State::pGLContext->RecordError(
ErrorCode::InvalidValue, ErrorCode::InvalidValue,
MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "`bufSize` is less than 0."));
"`bufSize` is less than 0."));
return; return;
} }
auto programObject = TryToGetProgramObject(program); auto programObject = TryToGetProgramObject(program);
if (!programObject) if (!programObject) return;
return;
auto uniformCount = programObject->GetUniformCount(); auto uniformCount = programObject->GetUniformCount();
if (index >= uniformCount) { if (index >= uniformCount) {
MG_State::pGLContext->RecordError( MG_State::pGLContext->RecordError(
ErrorCode::InvalidValue, ErrorCode::InvalidValue,
MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, MakeShared<GenericErrorInfo>(
"`index` is greater than or equal to the number of active uniform variables in `program`.")); "MG_Impl/GLImpl", __func__,
"`index` is greater than or equal to the number of active uniform variables in `program`."));
return; return;
} }
if (type != nullptr) if (type != nullptr) *type = programObject->GetUniformType(index);
*type = programObject->GetUniformType(index);
if (bufSize == 0) return; if (bufSize == 0) return;
auto& uniformName = programObject->GetUniformName(index); auto& uniformName = programObject->GetUniformName(index);
CopyStr(bufSize, length, name, uniformName.c_str(), uniformName.length()); CopyStr(bufSize, length, name, uniformName.c_str(), uniformName.length());
@@ -219,18 +201,15 @@ namespace MobileGL {
void GetAttachedShaders_State(GLuint program, GLsizei maxCount, GLsizei* count, GLuint* shaders) { void GetAttachedShaders_State(GLuint program, GLsizei maxCount, GLsizei* count, GLuint* shaders) {
if (maxCount < 0) { if (maxCount < 0) {
MG_State::pGLContext->RecordError( MG_State::pGLContext->RecordError(
ErrorCode::InvalidValue, ErrorCode::InvalidValue,
MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "`maxCount` is less than 0."));
"`maxCount` is less than 0."));
return; return;
} }
auto programObject = TryToGetProgramObject(program); auto programObject = TryToGetProgramObject(program);
if (!programObject) if (!programObject) return;
return;
const auto& s = programObject->GetAttachedShaders(); const auto& s = programObject->GetAttachedShaders();
GLsizei c = std::min((GLsizei)s.size(), maxCount); GLsizei c = std::min((GLsizei)s.size(), maxCount);
if (count) if (count) *count = c;
*count = c;
for (GLsizei i = 0; i < c; ++i) { for (GLsizei i = 0; i < c; ++i) {
shaders[i] = s[i]->GetId(); shaders[i] = s[i]->GetId();
} }
@@ -238,84 +217,78 @@ namespace MobileGL {
GLint GetAttribLocation_State(GLuint program, const GLchar* name) { GLint GetAttribLocation_State(GLuint program, const GLchar* name) {
auto programObject = TryToGetProgramObject(program); auto programObject = TryToGetProgramObject(program);
if (!programObject) if (!programObject) return -1;
return -1; if (strncmp(name, "gl_", 3) == 0) return -1;
if (strncmp(name, "gl_", 3) == 0) if (!programObject->GetLinkStatus()) return -1;
return -1;
if (!programObject->GetLinkStatus())
return -1;
return programObject->GetAttributeLocation(name); return programObject->GetAttributeLocation(name);
} }
void GetProgramiv_State(GLuint program, GLenum pname, GLint* params) { void GetProgramiv_State(GLuint program, GLenum pname, GLint* params) {
auto programObject = TryToGetProgramObject(program); auto programObject = TryToGetProgramObject(program);
if (!programObject) if (!programObject) return;
return;
switch (pname) { switch (pname) {
case GL_DELETE_STATUS: case GL_DELETE_STATUS:
*params = programObject->GetDeleteStatus(); *params = programObject->GetDeleteStatus();
break; break;
case GL_LINK_STATUS: case GL_LINK_STATUS:
*params = programObject->GetLinkStatus(); *params = programObject->GetLinkStatus();
break; break;
case GL_VALIDATE_STATUS: case GL_VALIDATE_STATUS:
*params = programObject->GetValidateStatus(); *params = programObject->GetValidateStatus();
break; break;
case GL_INFO_LOG_LENGTH: { case GL_INFO_LOG_LENGTH: {
const auto& log = programObject->GetInfoLog(); const auto& log = programObject->GetInfoLog();
*params = log.length(); *params = log.length();
break; break;
} }
case GL_ATTACHED_SHADERS: { case GL_ATTACHED_SHADERS: {
const auto& attachedShaders = programObject->GetAttachedShaders(); const auto& attachedShaders = programObject->GetAttachedShaders();
*params = attachedShaders.size(); *params = attachedShaders.size();
break; break;
} }
case GL_ACTIVE_ATOMIC_COUNTER_BUFFERS: case GL_ACTIVE_ATOMIC_COUNTER_BUFFERS:
*params = programObject->GetActiveAtomicCounterCount(); *params = programObject->GetActiveAtomicCounterCount();
break; break;
case GL_ACTIVE_ATTRIBUTES: case GL_ACTIVE_ATTRIBUTES:
*params = programObject->GetActiveAttributesCount(); *params = programObject->GetActiveAttributesCount();
break; break;
case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH: case GL_ACTIVE_ATTRIBUTE_MAX_LENGTH:
*params = programObject->GetActiveAttributesMaxLength(); *params = programObject->GetActiveAttributesMaxLength();
break; break;
case GL_ACTIVE_UNIFORMS: case GL_ACTIVE_UNIFORMS:
*params = programObject->GetUniformCount(); *params = programObject->GetUniformCount();
break; break;
case GL_ACTIVE_UNIFORM_MAX_LENGTH: case GL_ACTIVE_UNIFORM_MAX_LENGTH:
*params = programObject->GetUniformMaxLength(); *params = programObject->GetUniformMaxLength();
break; break;
case GL_ACTIVE_UNIFORM_BLOCKS: // GL >= 3.1 case GL_ACTIVE_UNIFORM_BLOCKS: // GL >= 3.1
*params = programObject->GetActiveUniformBlocksCount(); *params = programObject->GetActiveUniformBlocksCount();
break; break;
case GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH: // ditto. case GL_ACTIVE_UNIFORM_BLOCK_MAX_NAME_LENGTH: // ditto.
*params = programObject->GetActiveUniformBlocksMaxNameLength(); *params = programObject->GetActiveUniformBlocksMaxNameLength();
break; break;
case GL_COMPUTE_WORK_GROUP_SIZE: // GL >= 4.3 case GL_COMPUTE_WORK_GROUP_SIZE: // GL >= 4.3
case GL_PROGRAM_BINARY_LENGTH: case GL_PROGRAM_BINARY_LENGTH:
case GL_TRANSFORM_FEEDBACK_BUFFER_MODE: case GL_TRANSFORM_FEEDBACK_BUFFER_MODE:
case GL_TRANSFORM_FEEDBACK_VARYINGS: case GL_TRANSFORM_FEEDBACK_VARYINGS:
case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH: case GL_TRANSFORM_FEEDBACK_VARYING_MAX_LENGTH:
case GL_GEOMETRY_VERTICES_OUT: case GL_GEOMETRY_VERTICES_OUT:
case GL_GEOMETRY_INPUT_TYPE: case GL_GEOMETRY_INPUT_TYPE:
case GL_GEOMETRY_OUTPUT_TYPE: case GL_GEOMETRY_OUTPUT_TYPE:
default: default:
MG_State::pGLContext->RecordError( MG_State::pGLContext->RecordError(
ErrorCode::InvalidEnum, ErrorCode::InvalidEnum,
MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "`pname` is not an accepted value."));
"`pname` is not an accepted value.")); return;
return;
} }
} }
void GetProgramInfoLog_State(GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog) { void GetProgramInfoLog_State(GLuint program, GLsizei bufSize, GLsizei* length, GLchar* infoLog) {
auto programObject = TryToGetProgramObject(program); auto programObject = TryToGetProgramObject(program);
if (!programObject) if (!programObject) return;
return;
const auto& log = programObject->GetInfoLog(); const auto& log = programObject->GetInfoLog();
CopyStr(bufSize, length, infoLog, log.c_str(), log.length()); CopyStr(bufSize, length, infoLog, log.c_str(), log.length());
@@ -323,38 +296,35 @@ namespace MobileGL {
void GetShaderiv_State(GLuint shader, GLenum pname, GLint* params) { void GetShaderiv_State(GLuint shader, GLenum pname, GLint* params) {
auto shaderObject = TryToGetShaderObject(shader); auto shaderObject = TryToGetShaderObject(shader);
if (!shaderObject) if (!shaderObject) return;
return;
switch (pname) { switch (pname) {
case GL_SHADER_TYPE: case GL_SHADER_TYPE:
*params = ConvertGLShaderTypeByMGLShaderStage(shaderObject->GetShaderStage()); *params = ConvertGLShaderTypeByMGLShaderStage(shaderObject->GetShaderStage());
break; break;
case GL_DELETE_STATUS: case GL_DELETE_STATUS:
*params = shaderObject->GetDeleteStatus(); *params = shaderObject->GetDeleteStatus();
break; break;
case GL_COMPILE_STATUS: case GL_COMPILE_STATUS:
*params = shaderObject->GetCompileStatus(); *params = shaderObject->GetCompileStatus();
break; break;
case GL_INFO_LOG_LENGTH: case GL_INFO_LOG_LENGTH:
*params = shaderObject->GetInfoLog().length(); *params = shaderObject->GetInfoLog().length();
break; break;
case GL_SHADER_SOURCE_LENGTH: case GL_SHADER_SOURCE_LENGTH:
*params = shaderObject->GetShaderSource().length(); *params = shaderObject->GetShaderSource().length();
break; break;
default: default:
MG_State::pGLContext->RecordError( MG_State::pGLContext->RecordError(
ErrorCode::InvalidEnum, ErrorCode::InvalidEnum,
MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "`pname` is not an accepted value."));
"`pname` is not an accepted value.")); return;
return;
} }
} }
void GetShaderInfoLog_State(GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog) { void GetShaderInfoLog_State(GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* infoLog) {
auto shaderObject = TryToGetShaderObject(shader); auto shaderObject = TryToGetShaderObject(shader);
if (!shaderObject) if (!shaderObject) return;
return;
const auto& log = shaderObject->GetInfoLog(); const auto& log = shaderObject->GetInfoLog();
CopyStr(bufSize, length, infoLog, log.c_str(), log.length()); CopyStr(bufSize, length, infoLog, log.c_str(), log.length());
@@ -363,14 +333,12 @@ namespace MobileGL {
void GetShaderSource_State(GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source) { void GetShaderSource_State(GLuint shader, GLsizei bufSize, GLsizei* length, GLchar* source) {
if (bufSize < 0) { if (bufSize < 0) {
MG_State::pGLContext->RecordError( MG_State::pGLContext->RecordError(
ErrorCode::InvalidValue, ErrorCode::InvalidValue,
MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "`bufSize` is less than 0."));
"`bufSize` is less than 0."));
} }
auto shaderObject = TryToGetShaderObject(shader); auto shaderObject = TryToGetShaderObject(shader);
if (!shaderObject) if (!shaderObject) return;
return;
auto& src = shaderObject->GetShaderSource(); auto& src = shaderObject->GetShaderSource();
CopyStr(bufSize, length, source, src.c_str(), src.length()); CopyStr(bufSize, length, source, src.c_str(), src.length());
@@ -378,30 +346,29 @@ namespace MobileGL {
GLint GetUniformLocation_State(GLuint program, const GLchar* name) { GLint GetUniformLocation_State(GLuint program, const GLchar* name) {
auto programObject = TryToGetProgramObject(program); auto programObject = TryToGetProgramObject(program);
if (!programObject) if (!programObject) return -1;
return -1;
return programObject->GetUniformLocation(name); return programObject->GetUniformLocation(name);
} }
void GetUniform_State(GLuint program, GLint location, void* params) { void GetUniform_State(GLuint program, GLint location, void* params) {
auto programObject = TryToGetProgramObject(program); auto programObject = TryToGetProgramObject(program);
if (!programObject) if (!programObject) return;
return;
if (!programObject->GetLinkStatus()) { if (!programObject->GetLinkStatus()) {
MG_State::pGLContext->RecordError( MG_State::pGLContext->RecordError(
ErrorCode::InvalidOperation, ErrorCode::InvalidOperation,
MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
"`program` has not been successfully linked.")); "`program` has not been successfully linked."));
return; return;
} }
// Check if location is valid // Check if location is valid
if (location < 0 || location > programObject->GetMaxUniformLocation()) { if (location < 0 || location > programObject->GetMaxUniformLocation()) {
MG_State::pGLContext->RecordError( MG_State::pGLContext->RecordError(
ErrorCode::InvalidOperation, ErrorCode::InvalidOperation,
MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
"`location` does not correspond to a valid uniform variable location for the specified program object.")); "`location` does not correspond to a valid uniform variable location "
"for the specified program object."));
return; return;
} }
@@ -409,9 +376,10 @@ namespace MobileGL {
const auto& uniformName = programObject->GetUniformName(location); const auto& uniformName = programObject->GetUniformName(location);
if (uniformName.empty()) { if (uniformName.empty()) {
MG_State::pGLContext->RecordError( MG_State::pGLContext->RecordError(
ErrorCode::InvalidOperation, ErrorCode::InvalidOperation,
MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
"`location` does not correspond to a valid uniform variable location for the specified program object.")); "`location` does not correspond to a valid uniform variable location "
"for the specified program object."));
return; return;
} }
@@ -438,7 +406,7 @@ namespace MobileGL {
/* FIXME: Handle situations that: /* FIXME: Handle situations that:
* A program object marked for deletion with glDeleteProgram but still in use as part of current * A program object marked for deletion with glDeleteProgram but still in use as part of current
* rendering state is still considered a program object and glIsProgram will return GL_TRUE. * rendering state is still considered a program object and glIsProgram will return GL_TRUE.
*/ */
return CheckProgramNameValidity(program); return CheckProgramNameValidity(program);
} }
@@ -446,14 +414,13 @@ namespace MobileGL {
/* FIXME: Handle situations that: /* FIXME: Handle situations that:
* A shader object marked for deletion with glDeleteShader but still attached to a program object is still * A shader object marked for deletion with glDeleteShader but still attached to a program object is still
* considered a shader object and glIsShader will return GL_TRUE. * considered a shader object and glIsShader will return GL_TRUE.
*/ */
return CheckShaderNameValidity(shader); return CheckShaderNameValidity(shader);
} }
void LinkProgram_State(GLuint program) { void LinkProgram_State(GLuint program) {
auto programObject = TryToGetProgramObject(program); auto programObject = TryToGetProgramObject(program);
if (!programObject) if (!programObject) return;
return;
programObject->Link(); programObject->Link();
} }
@@ -461,19 +428,16 @@ namespace MobileGL {
if (count < 0) { if (count < 0) {
MG_State::pGLContext->RecordError( MG_State::pGLContext->RecordError(
ErrorCode::InvalidValue, ErrorCode::InvalidValue,
MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "`count` is less than 0."));
"`count` is less than 0."));
return; return;
} }
auto shaderObject = TryToGetShaderObject(shader); auto shaderObject = TryToGetShaderObject(shader);
if (!shaderObject) if (!shaderObject) return;
return;
std::string src; std::string src;
for (GLsizei i = 0; i < count; i++) { for (GLsizei i = 0; i < count; i++) {
src += src += (length == nullptr || length[i] <= 0) ? string[i] : std::string(string[i], length[i]);
(length == nullptr || length[i] <= 0) ? string[i] : std::string(string[i], length[i]);
} }
shaderObject->SetShaderSource(Move(src)); shaderObject->SetShaderSource(Move(src));
} }
@@ -485,8 +449,7 @@ namespace MobileGL {
} }
auto programObject = TryToGetProgramObject(program); auto programObject = TryToGetProgramObject(program);
if (!programObject) if (!programObject) return;
return;
MG_State::pGLContext->UseProgram(program); MG_State::pGLContext->UseProgram(program);
} }
@@ -500,15 +463,13 @@ namespace MobileGL {
template <GLsizei VecCount, typename T> template <GLsizei VecCount, typename T>
void Uniformv_State(GLint location, GLsizei count, T* value) { void Uniformv_State(GLint location, GLsizei count, T* value) {
if (location == -1) if (location == -1) return;
return;
auto programObject = MG_State::pGLContext->GetCurrentProgram(); auto programObject = MG_State::pGLContext->GetCurrentProgram();
if (programObject == nullptr) { if (programObject == nullptr) {
MG_State::pGLContext->RecordError( MG_State::pGLContext->RecordError(
ErrorCode::InvalidOperation, ErrorCode::InvalidOperation,
MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "There is no current program object."));
"There is no current program object."));
return; return;
} }
@@ -516,7 +477,8 @@ namespace MobileGL {
MG_State::pGLContext->RecordError( MG_State::pGLContext->RecordError(
ErrorCode::InvalidOperation, ErrorCode::InvalidOperation,
MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
"`location` is an invalid uniform location for the current program object and `location` is not equal to -1.")); "`location` is an invalid uniform location for the current program "
"object and `location` is not equal to -1."));
return; return;
} }
@@ -530,14 +492,14 @@ namespace MobileGL {
// Input matrix is in column-major order (OpenGL default) // Input matrix is in column-major order (OpenGL default)
// [0 2] // [0 2]
// [1 3] // [1 3]
// //
// Output matrix should be in row-major order if transpose is true // Output matrix should be in row-major order if transpose is true
// [0 1] // [0 1]
// [2 3] // [2 3]
output[0] = input[0]; // 0,0 element stays the same output[0] = input[0]; // 0,0 element stays the same
output[1] = input[2]; // 0,1 element becomes 1,0 output[1] = input[2]; // 0,1 element becomes 1,0
output[2] = input[1]; // 1,0 element becomes 0,1 output[2] = input[1]; // 1,0 element becomes 0,1
output[3] = input[3]; // 1,1 element stays the same output[3] = input[3]; // 1,1 element stays the same
} }
// Helper function to transpose a 3x3 matrix // Helper function to transpose a 3x3 matrix
@@ -546,20 +508,20 @@ namespace MobileGL {
// [0 3 6] // [0 3 6]
// [1 4 7] // [1 4 7]
// [2 5 8] // [2 5 8]
// //
// Output matrix should be in row-major order if transpose is true // Output matrix should be in row-major order if transpose is true
// [0 1 2] // [0 1 2]
// [3 4 5] // [3 4 5]
// [6 7 8] // [6 7 8]
output[0] = input[0]; // 0,0 element stays the same output[0] = input[0]; // 0,0 element stays the same
output[1] = input[3]; // 0,1 element becomes 1,0 output[1] = input[3]; // 0,1 element becomes 1,0
output[2] = input[6]; // 0,2 element becomes 2,0 output[2] = input[6]; // 0,2 element becomes 2,0
output[3] = input[1]; // 1,0 element becomes 0,1 output[3] = input[1]; // 1,0 element becomes 0,1
output[4] = input[4]; // 1,1 element stays the same output[4] = input[4]; // 1,1 element stays the same
output[5] = input[7]; // 1,2 element becomes 2,1 output[5] = input[7]; // 1,2 element becomes 2,1
output[6] = input[2]; // 2,0 element becomes 0,2 output[6] = input[2]; // 2,0 element becomes 0,2
output[7] = input[5]; // 2,1 element becomes 1,2 output[7] = input[5]; // 2,1 element becomes 1,2
output[8] = input[8]; // 2,2 element stays the same output[8] = input[8]; // 2,2 element stays the same
} }
// Helper function to transpose a 4x4 matrix // Helper function to transpose a 4x4 matrix
@@ -569,7 +531,7 @@ namespace MobileGL {
// [1 5 9 13] // [1 5 9 13]
// [2 6 10 14] // [2 6 10 14]
// [3 7 11 15] // [3 7 11 15]
// //
// Output matrix should be in row-major order if transpose is true // Output matrix should be in row-major order if transpose is true
// [0 1 2 3] // [0 1 2 3]
// [4 5 6 7] // [4 5 6 7]
@@ -628,15 +590,13 @@ namespace MobileGL {
void UniformMatrix2fv_State(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) { void UniformMatrix2fv_State(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) {
// For 2x2 matrices, we have 4 elements per matrix // For 2x2 matrices, we have 4 elements per matrix
// If transpose is GL_TRUE, we need to transpose the matrix data // If transpose is GL_TRUE, we need to transpose the matrix data
if (location == -1) if (location == -1) return;
return;
auto programObject = MG_State::pGLContext->GetCurrentProgram(); auto programObject = MG_State::pGLContext->GetCurrentProgram();
if (programObject == nullptr) { if (programObject == nullptr) {
MG_State::pGLContext->RecordError( MG_State::pGLContext->RecordError(
ErrorCode::InvalidOperation, ErrorCode::InvalidOperation,
MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "There is no current program object."));
"There is no current program object."));
return; return;
} }
@@ -644,7 +604,8 @@ namespace MobileGL {
MG_State::pGLContext->RecordError( MG_State::pGLContext->RecordError(
ErrorCode::InvalidOperation, ErrorCode::InvalidOperation,
MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
"`location` is an invalid uniform location for the current program object and `location` is not equal to -1.")); "`location` is an invalid uniform location for the current program "
"object and `location` is not equal to -1."));
return; return;
} }
@@ -665,15 +626,13 @@ namespace MobileGL {
void UniformMatrix3fv_State(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) { void UniformMatrix3fv_State(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) {
// For 3x3 matrices, we have 9 elements per matrix // For 3x3 matrices, we have 9 elements per matrix
// If transpose is GL_TRUE, we need to transpose the matrix data // If transpose is GL_TRUE, we need to transpose the matrix data
if (location == -1) if (location == -1) return;
return;
auto programObject = MG_State::pGLContext->GetCurrentProgram(); auto programObject = MG_State::pGLContext->GetCurrentProgram();
if (programObject == nullptr) { if (programObject == nullptr) {
MG_State::pGLContext->RecordError( MG_State::pGLContext->RecordError(
ErrorCode::InvalidOperation, ErrorCode::InvalidOperation,
MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "There is no current program object."));
"There is no current program object."));
return; return;
} }
@@ -681,7 +640,8 @@ namespace MobileGL {
MG_State::pGLContext->RecordError( MG_State::pGLContext->RecordError(
ErrorCode::InvalidOperation, ErrorCode::InvalidOperation,
MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
"`location` is an invalid uniform location for the current program object and `location` is not equal to -1.")); "`location` is an invalid uniform location for the current program "
"object and `location` is not equal to -1."));
return; return;
} }
@@ -702,15 +662,13 @@ namespace MobileGL {
void UniformMatrix4fv_State(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) { void UniformMatrix4fv_State(GLint location, GLsizei count, GLboolean transpose, const GLfloat* value) {
// For 4x4 matrices, we have 16 elements per matrix // For 4x4 matrices, we have 16 elements per matrix
// If transpose is GL_TRUE, we need to transpose the matrix data // If transpose is GL_TRUE, we need to transpose the matrix data
if (location == -1) if (location == -1) return;
return;
auto programObject = MG_State::pGLContext->GetCurrentProgram(); auto programObject = MG_State::pGLContext->GetCurrentProgram();
if (programObject == nullptr) { if (programObject == nullptr) {
MG_State::pGLContext->RecordError( MG_State::pGLContext->RecordError(
ErrorCode::InvalidOperation, ErrorCode::InvalidOperation,
MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, "There is no current program object."));
"There is no current program object."));
return; return;
} }
@@ -718,7 +676,8 @@ namespace MobileGL {
MG_State::pGLContext->RecordError( MG_State::pGLContext->RecordError(
ErrorCode::InvalidOperation, ErrorCode::InvalidOperation,
MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__, MakeShared<GenericErrorInfo>("MG_Impl/GLImpl", __func__,
"`location` is an invalid uniform location for the current program object and `location` is not equal to -1.")); "`location` is an invalid uniform location for the current program "
"object and `location` is not equal to -1."));
return; return;
} }
@@ -820,7 +779,7 @@ namespace MobileGL {
void GetUniformiv(GLuint program, GLint location, GLint* params) { void GetUniformiv(GLuint program, GLint location, GLint* params) {
GetUniformiv_State(program, location, params); GetUniformiv_State(program, location, params);
} }
GLboolean IsProgram(GLuint program) { GLboolean IsProgram(GLuint program) {
return IsProgram_State(program); return IsProgram_State(program);
} }
MobileGL/MG_State/GLState/ErrorState/ErrorCode.h
+1 -1
View File
@@ -11,4 +11,4 @@ namespace MobileGL {
StackUnderflow, StackUnderflow,
StackOverflow StackOverflow
}; };
} } // namespace MobileGL
MobileGL/MG_State/GLState/ProgramState/ProgramObject.cpp
+38 -43
View File
@@ -90,7 +90,7 @@ namespace MobileGL {
auto location = uniform.layoutLocation(); auto location = uniform.layoutLocation();
m_uniformNames[location] = uniform.name; m_uniformNames[location] = uniform.name;
m_uniformTypes[location] = uniform.glDefineType; m_uniformTypes[location] = uniform.glDefineType;
m_uniformIsOpaqueType[location] = uniform.getType()->isOpaque(); m_uniformIsOpaqueType[location] = uniform.getType()->isOpaque();
m_uniformArraySizes[location] = uniform.size; m_uniformArraySizes[location] = uniform.size;
} }
@@ -108,12 +108,11 @@ namespace MobileGL {
m_attribTypes[location] = inVar.glDefineType; m_attribTypes[location] = inVar.glDefineType;
} }
// Implement glBindAttribLocation semantics // Implement glBindAttribLocation semantics
for (auto& [name, location]: m_explicitAttribLocations) { for (auto& [name, location] : m_explicitAttribLocations) {
assert(location < m_attribs.size()); assert(location < m_attribs.size());
if (m_attribs[location] != name) { if (m_attribs[location] != name) {
auto it = std::find(m_attribs.begin(), m_attribs.end(), name); auto it = std::find(m_attribs.begin(), m_attribs.end(), name);
if (it == m_attribs.end()) if (it == m_attribs.end()) continue;
continue;
std::swap(m_attribs[location], m_attribs[std::distance(m_attribs.begin(), it)]); std::swap(m_attribs[location], m_attribs[std::distance(m_attribs.begin(), it)]);
std::swap(m_attribTypes[location], m_attribTypes[std::distance(m_attribs.begin(), it)]); std::swap(m_attribTypes[location], m_attribTypes[std::distance(m_attribs.begin(), it)]);
} }
@@ -139,24 +138,21 @@ namespace MobileGL {
for (SizeT i = 0; i < m_shaders.size(); i++) { for (SizeT i = 0; i < m_shaders.size(); i++) {
auto shaderType = ConvertGLShaderTypeByMGLShaderStage(m_shaders[i]->GetShaderStage()); auto shaderType = ConvertGLShaderTypeByMGLShaderStage(m_shaders[i]->GetShaderStage());
shaderTypes[i] = shaderType; shaderTypes[i] = shaderType;
ShaderAttrib attrib { ShaderAttrib attrib{
.shaderType = shaderType, .shaderType = shaderType, .sourceStr = m_shaders[i]->GetShaderSource(), .flags = 0};
.sourceStr = m_shaders[i]->GetShaderSource(),
.flags = 0
};
auto res = ShaderCompiler::CompileShader(attrib); auto res = ShaderCompiler::CompileShader(attrib);
assert(res); assert(res);
shaders[i] = res.value(); shaders[i] = res.value();
} }
ProgramAttrib attrib { ProgramAttrib attrib{
.shaders = Move(shaders), .shaders = Move(shaders),
}; };
auto programResult = ShaderCompiler::LinkProgram(attrib); auto programResult = ShaderCompiler::LinkProgram(attrib);
assert(programResult); assert(programResult);
auto program = programResult.value(); auto program = programResult.value();
ProgramBinaryAttrib binaryAttrib { ProgramBinaryAttrib binaryAttrib{
.shaderTypes = shaderTypes, .shaderTypes = shaderTypes,
.program = *program, .program = *program,
}; };
@@ -187,10 +183,9 @@ namespace MobileGL {
// assert(m_uniformSizesInBytes.size() == GetUniformCount()); // assert(m_uniformSizesInBytes.size() == GetUniformCount());
} }
void ProgramObject::WaitUntilGenerationCompleted() { void ProgramObject::WaitUntilGenerationCompleted() {}
}
void ProgramObject::SetExplicitAttribLocation(Uint index, const char *name) { void ProgramObject::SetExplicitAttribLocation(Uint index, const char* name) {
m_explicitAttribLocations[name] = index; m_explicitAttribLocations[name] = index;
} }
@@ -257,35 +252,35 @@ namespace MobileGL {
// } // }
// //
// void ProgramObject::PostLink() { // void ProgramObject::PostLink() {
// if (m_programBinary.empty()) { // if (m_programBinary.empty()) {
// assert(false); // assert(false);
// return; // return;
// } // }
// MG_Util::ShaderTranspiler::SpvcSession session(m_programBinary[0]); // MG_Util::ShaderTranspiler::SpvcSession session(m_programBinary[0]);
// const char* src = nullptr; // we don't care the source atm // const char* src = nullptr; // we don't care the source atm
// auto result = session.Compile(&src); // auto result = session.Compile(&src);
// if (result != SPVC_SUCCESS) { // if (result != SPVC_SUCCESS) {
// assert(false); // assert(false);
// return; // return;
// } // }
// m_metadata = session.GetMetadata(); // m_metadata = session.GetMetadata();
// auto& uniformOffsets = m_metadata.plainUniformOffsetsInUBO; // auto& uniformOffsets = m_metadata.plainUniformOffsetsInUBO;
// for (const auto& [name, offset] : uniformOffsets) { // for (const auto& [name, offset] : uniformOffsets) {
// assert(m_uniforms.find(name) != m_uniforms.end()); // assert(m_uniforms.find(name) != m_uniforms.end());
// assert(m_uniforms[name] < m_uniformOffsets.size()); // assert(m_uniforms[name] < m_uniformOffsets.size());
// m_uniformOffsets[m_uniforms[name]] = offset; // m_uniformOffsets[m_uniforms[name]] = offset;
// } // }
// m_uboScratch.resize(m_metadata.uboSize, 0); // m_uboScratch.resize(m_metadata.uboSize, 0);
// //
// auto& types = m_metadata.plainUniformMemberTypes; // auto& types = m_metadata.plainUniformMemberTypes;
// //
// assert(types.size() == m_uniformOffsets.size()); // assert(types.size() == m_uniformOffsets.size());
// m_uniformTypes.resize(m_uniformOffsets.size()); // m_uniformTypes.resize(m_uniformOffsets.size());
// for (const auto& [name, type] : types) { // for (const auto& [name, type] : types) {
// auto gltype = MG_Util::ConvertSpvcTypeToGLEnum(type); // auto gltype = MG_Util::ConvertSpvcTypeToGLEnum(type);
// auto location = m_uniforms[name]; // auto location = m_uniforms[name];
// m_uniformTypes[location] = gltype; // m_uniformTypes[location] = gltype;
// } // }
// } // }
} // namespace GLState } // namespace GLState
} // namespace MG_State } // namespace MG_State
MobileGL/MG_State/GLState/ProgramState/ProgramObject.h
+9 -22
View File
@@ -9,7 +9,7 @@ namespace MobileGL {
namespace GLState { namespace GLState {
class ProgramObject { class ProgramObject {
public: public:
ProgramObject(const Uint id): m_id(id) {} ProgramObject(const Uint id) : m_id(id) {}
bool ShaderIsAttached(SharedPtr<ShaderObject> shader); bool ShaderIsAttached(SharedPtr<ShaderObject> shader);
bool AttachShader(SharedPtr<ShaderObject> shader); bool AttachShader(SharedPtr<ShaderObject> shader);
SizeT DetachShader(SharedPtr<ShaderObject> shader); SizeT DetachShader(SharedPtr<ShaderObject> shader);
@@ -27,20 +27,12 @@ namespace MobileGL {
const auto it = m_uniformLocations.find(name); const auto it = m_uniformLocations.find(name);
return (it == m_uniformLocations.end()) ? -1 : (Int)it->second; return (it == m_uniformLocations.end()) ? -1 : (Int)it->second;
} }
GLenum GetUniformType(Uint index) const { GLenum GetUniformType(Uint index) const { return m_uniformTypes[index]; }
return m_uniformTypes[index];
}
Bool IsUniformOpaqueAtLocation(Uint location) const { Bool IsUniformOpaqueAtLocation(Uint location) const { return m_uniformIsOpaqueType[location]; }
return m_uniformIsOpaqueType[location];
}
const String& GetUniformName(Uint index) const { const String& GetUniformName(Uint index) const { return m_uniformNames[index]; }
return m_uniformNames[index]; Uint GetUniformOffset(Uint location) const { return m_uniformOffsets[location]; }
}
Uint GetUniformOffset(Uint location) const {
return m_uniformOffsets[location];
}
Uint GetUniformSizesInBytes(Uint location) const { Uint GetUniformSizesInBytes(Uint location) const {
return MG_Util::GetGLTypeSize(m_uniformTypes[location]); return MG_Util::GetGLTypeSize(m_uniformTypes[location]);
} }
@@ -49,15 +41,9 @@ namespace MobileGL {
const auto it = std::find(m_attribs.begin(), m_attribs.end(), name); const auto it = std::find(m_attribs.begin(), m_attribs.end(), name);
return (it == m_attribs.end()) ? -1 : std::distance(m_attribs.begin(), it); return (it == m_attribs.end()) ? -1 : std::distance(m_attribs.begin(), it);
} }
GLenum GetAttribType(Uint index) const { GLenum GetAttribType(Uint index) const { return m_attribTypes[index]; }
return m_attribTypes[index]; const String& GetAttribName(Uint index) const { return m_attribs[index]; }
} void* MapUBO() { return m_uboScratch.data(); }
const String& GetAttribName(Uint index) const {
return m_attribs[index];
}
void* MapUBO() {
return m_uboScratch.data();
}
Bool GetDeleteStatus() const { return m_deleteStatus; } Bool GetDeleteStatus() const { return m_deleteStatus; }
Bool GetLinkStatus() const { return m_linkStatus; } Bool GetLinkStatus() const { return m_linkStatus; }
@@ -67,6 +53,7 @@ namespace MobileGL {
Int GetActiveUniformBlocksCount() const { return m_program->getNumUniformBlocks(); } Int GetActiveUniformBlocksCount() const { return m_program->getNumUniformBlocks(); }
Int GetActiveAttributesMaxLength() const { return m_attribInNameMaxLength; } Int GetActiveAttributesMaxLength() const { return m_attribInNameMaxLength; }
Int GetActiveUniformBlocksMaxNameLength() const { return m_uniformBlockNameMaxLength; } Int GetActiveUniformBlocksMaxNameLength() const { return m_uniformBlockNameMaxLength; }
private: private:
void DoReflection(); void DoReflection();
void GenerateBinary(); void GenerateBinary();
MobileGL/MG_State/GLState/ProgramState/ProgramState.cpp
+3 -6
View File
@@ -8,8 +8,7 @@ namespace MobileGL {
m_programIndexGenerator.Generate(1, &programId); m_programIndexGenerator.Generate(1, &programId);
EnsureIndexAvail(programId, m_programObjects); EnsureIndexAvail(programId, m_programObjects);
auto programObject = MakeShared<ProgramObject>(programId); auto programObject = MakeShared<ProgramObject>(programId);
if (programObject == nullptr) if (programObject == nullptr) return 0;
return 0;
m_programObjects[programId] = programObject; m_programObjects[programId] = programObject;
return programId; return programId;
} }
@@ -34,8 +33,7 @@ namespace MobileGL {
} }
void ProgramState::UseProgram(Uint program) { void ProgramState::UseProgram(Uint program) {
if (program == 0) if (program == 0) m_currentProgram.reset();
m_currentProgram.reset();
if (!CheckIndexAvail(program, m_programObjects)) return; if (!CheckIndexAvail(program, m_programObjects)) return;
m_currentProgram = m_programObjects[program]; m_currentProgram = m_programObjects[program];
@@ -46,8 +44,7 @@ namespace MobileGL {
m_shaderIndexGenerator.Generate(1, &shaderId); m_shaderIndexGenerator.Generate(1, &shaderId);
EnsureIndexAvail(shaderId, m_shaderObjects); EnsureIndexAvail(shaderId, m_shaderObjects);
auto shaderObject = MakeShared<ShaderObject>(stage, shaderId); auto shaderObject = MakeShared<ShaderObject>(stage, shaderId);
if (shaderObject == nullptr) if (shaderObject == nullptr) return 0;
return 0;
m_shaderObjects[shaderId] = shaderObject; m_shaderObjects[shaderId] = shaderObject;
return shaderId; return shaderId;
} }
MobileGL/MG_State/GLState/ProgramState/ProgramState.h
+2 -3
View File
@@ -22,9 +22,8 @@ namespace MobileGL {
void MarkShaderObjectForDeletion(Uint shader); void MarkShaderObjectForDeletion(Uint shader);
Bool ValidateShaderObject(Uint shader) const; Bool ValidateShaderObject(Uint shader) const;
SharedPtr<ProgramObject> GetCurrentProgram() const { SharedPtr<ProgramObject> GetCurrentProgram() const { return m_currentProgram; }
return m_currentProgram;
}
private: private:
template <typename T> template <typename T>
static Bool CheckIndexAvail(const SizeT idx, const Vector<T>& vec) { static Bool CheckIndexAvail(const SizeT idx, const Vector<T>& vec) {
MobileGL/MG_State/GLState/ProgramState/ShaderObject.cpp
+4 -6
View File
@@ -10,7 +10,7 @@ namespace MobileGL {
m_source = source; m_source = source;
} }
void ShaderObject::SetShaderSource(String &&source) { void ShaderObject::SetShaderSource(String&& source) {
m_source = Move(source); m_source = Move(source);
} }
@@ -24,11 +24,9 @@ namespace MobileGL {
// Compile for OpenGL here, so that we can do validation and link // Compile for OpenGL here, so that we can do validation and link
// like a real OpenGL driver at linking stage // like a real OpenGL driver at linking stage
// Will compile for other backends later. // Will compile for other backends later.
ShaderAttrib attrib{ ShaderAttrib attrib{.shaderType = ConvertGLShaderTypeByMGLShaderStage(m_stage),
.shaderType = ConvertGLShaderTypeByMGLShaderStage(m_stage), .sourceStr = m_source,
.sourceStr = m_source, .flags = ShaderCompileBits::CompileForOpenGL};
.flags = ShaderCompileBits::CompileForOpenGL
};
auto result = ShaderCompiler::CompileShader(attrib); auto result = ShaderCompiler::CompileShader(attrib);
if (result) { if (result) {
MobileGL/MG_State/GLState/ProgramState/ShaderObject.h
+16 -15
View File
@@ -36,21 +36,21 @@ namespace MobileGL {
inline static ShaderStage ConvertMGLShaderStageByGLShaderType(GLenum type) { inline static ShaderStage ConvertMGLShaderStageByGLShaderType(GLenum type) {
switch (type) { switch (type) {
case GL_VERTEX_SHADER: case GL_VERTEX_SHADER:
return ShaderStage::Vertex; return ShaderStage::Vertex;
case GL_TESS_CONTROL_SHADER: case GL_TESS_CONTROL_SHADER:
return ShaderStage::TessControl; return ShaderStage::TessControl;
case GL_TESS_EVALUATION_SHADER: case GL_TESS_EVALUATION_SHADER:
return ShaderStage::TessEval; return ShaderStage::TessEval;
case GL_GEOMETRY_SHADER: case GL_GEOMETRY_SHADER:
return ShaderStage::Geometry; return ShaderStage::Geometry;
case GL_FRAGMENT_SHADER: case GL_FRAGMENT_SHADER:
return ShaderStage::Fragment; return ShaderStage::Fragment;
case GL_COMPUTE_SHADER: case GL_COMPUTE_SHADER:
return ShaderStage::Compute; return ShaderStage::Compute;
default: default:
assert(false); assert(false);
return ShaderStage::Unknown; return ShaderStage::Unknown;
} }
} }
@@ -70,6 +70,7 @@ namespace MobileGL {
const UnorderedMap<String, Uint>& GetUniformLocations() const { return m_uniforms; } const UnorderedMap<String, Uint>& GetUniformLocations() const { return m_uniforms; }
Bool GetCompileStatus() const { return m_compileStatus; } Bool GetCompileStatus() const { return m_compileStatus; }
Bool GetDeleteStatus() const { return m_deleteStatus; } Bool GetDeleteStatus() const { return m_deleteStatus; }
private: private:
// bool DoReflection(); // bool DoReflection();
const Uint m_id = 0; const Uint m_id = 0;
MobileGL/MG_Test/Buffer/BufferTest.cpp
+52 -82
View File
@@ -50,12 +50,12 @@ TEST_F(BufferTest, PingPong) {
auto bufWrite = writeSlot.GetBoundObject(); auto bufWrite = writeSlot.GetBoundObject();
Vector<Int> data { 1, 2, 3, 4, 5 }; Vector<Int> data{1, 2, 3, 4, 5};
SizeT byteSize = data.size() * sizeof(Int); SizeT byteSize = data.size() * sizeof(Int);
// Write data // Write data
bufWrite->Resize(byteSize); bufWrite->Resize(byteSize);
DataPtr ptr { .data = data.data(), .size = byteSize }; DataPtr ptr{.data = data.data(), .size = byteSize};
bufWrite->UploadData(ptr, 0); bufWrite->UploadData(ptr, 0);
// Readback // Readback
@@ -70,20 +70,20 @@ TEST_F(BufferTest, PingPong) {
} }
TEST_F(BufferTest, GenerateManyNames_NoPrematureCreation) { TEST_F(BufferTest, GenerateManyNames_NoPrematureCreation) {
const SizeT largeCount = 100000; // generate tons of buffer names const SizeT largeCount = 100000; // generate tons of buffer names
auto names = glContext.GenBufferNames(largeCount); auto names = glContext.GenBufferNames(largeCount);
std::vector<SizeT> indices = { 0, 600, 5000, 32768, 99999 }; // only create a few buffer objects std::vector<SizeT> indices = {0, 600, 5000, 32768, 99999}; // only create a few buffer objects
for (SizeT idx : indices) { for (SizeT idx : indices) {
GLuint name = names[idx]; GLuint name = names[idx];
auto bufObj = glContext.CreateBufferObject(name); auto bufObj = glContext.CreateBufferObject(name);
auto& slot = glContext.GetBufferBindingSlot(BufferTarget::Uniform); auto& slot = glContext.GetBufferBindingSlot(BufferTarget::Uniform);
slot.Bind(bufObj); slot.Bind(bufObj);
Vector<Int> data = { static_cast<Int>(idx + 1), static_cast<Int>(idx + 2) }; Vector<Int> data = {static_cast<Int>(idx + 1), static_cast<Int>(idx + 2)};
SizeT byteSize = data.size() * sizeof(Int); SizeT byteSize = data.size() * sizeof(Int);
bufObj->Resize(byteSize); bufObj->Resize(byteSize);
DataPtr ptr{ .data = data.data(), .size = byteSize }; DataPtr ptr{.data = data.data(), .size = byteSize};
bufObj->UploadData(ptr, 0); bufObj->UploadData(ptr, 0);
Vector<Int> actual(data.size()); Vector<Int> actual(data.size());
@@ -98,10 +98,10 @@ TEST_F(BufferTest, AcquireMemory) {
auto bufferNames = glContext.GenBufferNames(1); auto bufferNames = glContext.GenBufferNames(1);
auto bufObj = glContext.CreateBufferObject(bufferNames[0]); auto bufObj = glContext.CreateBufferObject(bufferNames[0]);
slot.Bind(bufObj); slot.Bind(bufObj);
Vector<Int> initData{ 10, 20, 30, 40, 50 }; Vector<Int> initData{10, 20, 30, 40, 50};
SizeT byteSize = initData.size() * sizeof(Int); SizeT byteSize = initData.size() * sizeof(Int);
bufObj->Resize(byteSize); bufObj->Resize(byteSize);
DataPtr ptr{ .data = initData.data(), .size = byteSize }; DataPtr ptr{.data = initData.data(), .size = byteSize};
bufObj->UploadData(ptr, 0); bufObj->UploadData(ptr, 0);
bufObj->ClearDirty(); bufObj->ClearDirty();
Int* mappedPtr = static_cast<Int*>(bufObj->AcquireMemory(true, true, true)); Int* mappedPtr = static_cast<Int*>(bufObj->AcquireMemory(true, true, true));
@@ -109,7 +109,7 @@ TEST_F(BufferTest, AcquireMemory) {
mappedPtr[1] = 200; mappedPtr[1] = 200;
mappedPtr[2] = 300; mappedPtr[2] = 300;
bufObj->ReleaseMemory(); bufObj->ReleaseMemory();
Vector<Int> expected{ 100, 200, 300, 40, 50 }; Vector<Int> expected{100, 200, 300, 40, 50};
Vector<Int> actual(5); Vector<Int> actual(5);
void* p = bufObj->AcquireMemory(false, true, false); void* p = bufObj->AcquireMemory(false, true, false);
memcpy(actual.data(), p, byteSize); memcpy(actual.data(), p, byteSize);
@@ -117,7 +117,7 @@ TEST_F(BufferTest, AcquireMemory) {
auto dirty = bufObj->GetDirtyRange(); auto dirty = bufObj->GetDirtyRange();
ASSERT_EQ(dirty.start, 0); ASSERT_EQ(dirty.start, 0);
ASSERT_EQ(dirty.end, sizeof(Int) * 5); ASSERT_EQ(dirty.end, sizeof(Int) * 5);
} }
TEST_F(BufferTest, AcquireMemoryRangeWithoutExplicit) { TEST_F(BufferTest, AcquireMemoryRangeWithoutExplicit) {
@@ -125,32 +125,26 @@ TEST_F(BufferTest, AcquireMemoryRangeWithoutExplicit) {
auto bufferNames = glContext.GenBufferNames(1); auto bufferNames = glContext.GenBufferNames(1);
auto bufObj = glContext.CreateBufferObject(bufferNames[0]); auto bufObj = glContext.CreateBufferObject(bufferNames[0]);
slot.Bind(bufObj); slot.Bind(bufObj);
Vector<Int> initData{ 10, 20, 30, 40, 50 }; Vector<Int> initData{10, 20, 30, 40, 50};
SizeT byteSize = initData.size() * sizeof(Int); SizeT byteSize = initData.size() * sizeof(Int);
bufObj->Resize(byteSize); bufObj->Resize(byteSize);
DataPtr ptr{ .data = initData.data(), .size = byteSize }; DataPtr ptr{.data = initData.data(), .size = byteSize};
bufObj->UploadData(ptr, 0); bufObj->UploadData(ptr, 0);
bufObj->ClearDirty(); bufObj->ClearDirty();
Range1D mapRange{ Range1D mapRange{.start = sizeof(Int), .end = sizeof(Int) * 4};
.start = sizeof(Int), Int* mappedPtr = static_cast<Int*>(bufObj->AcquireMemoryRange(mapRange, BufferMappingAccessBit::Write));
.end = sizeof(Int) * 4
};
Int* mappedPtr = static_cast<Int*>(bufObj->AcquireMemoryRange(
mapRange,
BufferMappingAccessBit::Write
));
mappedPtr[0] = 200; mappedPtr[0] = 200;
mappedPtr[1] = 300; mappedPtr[1] = 300;
bufObj->ReleaseMemory(); bufObj->ReleaseMemory();
Vector<Int> expected{ 10, 200, 300, 40, 50 }; Vector<Int> expected{10, 200, 300, 40, 50};
Vector<Int> actual(5); Vector<Int> actual(5);
void* p = bufObj->AcquireMemory(false, true, false); void* p = bufObj->AcquireMemory(false, true, false);
memcpy(actual.data(), p, byteSize); memcpy(actual.data(), p, byteSize);
ASSERT_EQ(actual, expected); ASSERT_EQ(actual, expected);
auto dirty = bufObj->GetDirtyRange(); auto dirty = bufObj->GetDirtyRange();
ASSERT_EQ(dirty.start, sizeof(Int)); ASSERT_EQ(dirty.start, sizeof(Int));
ASSERT_EQ(dirty.end, sizeof(Int) * 4); ASSERT_EQ(dirty.end, sizeof(Int) * 4);
} }
TEST_F(BufferTest, AcquireMemoryRangeWithExplicit) { TEST_F(BufferTest, AcquireMemoryRangeWithExplicit) {
@@ -159,30 +153,25 @@ TEST_F(BufferTest, AcquireMemoryRangeWithExplicit) {
auto bufObj = glContext.CreateBufferObject(bufferNames[0]); auto bufObj = glContext.CreateBufferObject(bufferNames[0]);
slot.Bind(bufObj); slot.Bind(bufObj);
Vector<Int> initData{ 10, 20, 30, 40, 50 }; Vector<Int> initData{10, 20, 30, 40, 50};
SizeT byteSize = initData.size() * sizeof(Int); SizeT byteSize = initData.size() * sizeof(Int);
bufObj->Resize(byteSize); bufObj->Resize(byteSize);
DataPtr ptr{ .data = initData.data(), .size = byteSize }; DataPtr ptr{.data = initData.data(), .size = byteSize};
bufObj->UploadData(ptr, 0); bufObj->UploadData(ptr, 0);
bufObj->ClearDirty(); bufObj->ClearDirty();
Range1D mapRange{ Range1D mapRange{.start = sizeof(Int), .end = sizeof(Int) * 4};
.start = sizeof(Int), Int* mappedPtr = static_cast<Int*>(
.end = sizeof(Int) * 4 bufObj->AcquireMemoryRange(mapRange, BufferMappingAccessBit::Write | BufferMappingAccessBit::FlushExplicit));
};
Int* mappedPtr = static_cast<Int*>(bufObj->AcquireMemoryRange(
mapRange,
BufferMappingAccessBit::Write | BufferMappingAccessBit::FlushExplicit
));
mappedPtr[0] = 200; mappedPtr[0] = 200;
mappedPtr[1] = 300; mappedPtr[1] = 300;
bufObj->FlushMemoryRange(0, sizeof(Int)); bufObj->FlushMemoryRange(0, sizeof(Int));
auto dirty = bufObj->GetDirtyRange(); auto dirty = bufObj->GetDirtyRange();
ASSERT_EQ(dirty.start, sizeof(Int)); ASSERT_EQ(dirty.start, sizeof(Int));
ASSERT_EQ(dirty.end, sizeof(Int) * 2); ASSERT_EQ(dirty.end, sizeof(Int) * 2);
bufObj->ReleaseMemory(); bufObj->ReleaseMemory();
@@ -190,7 +179,7 @@ TEST_F(BufferTest, AcquireMemoryRangeWithExplicit) {
ASSERT_EQ(dirty.start, sizeof(Int)); ASSERT_EQ(dirty.start, sizeof(Int));
ASSERT_EQ(dirty.end, sizeof(Int) * 2); ASSERT_EQ(dirty.end, sizeof(Int) * 2);
Vector<Int> expected{ 10, 200, 30, 40, 50 }; Vector<Int> expected{10, 200, 30, 40, 50};
Vector<Int> actual(5); Vector<Int> actual(5);
void* p = bufObj->AcquireMemory(false, true, false); void* p = bufObj->AcquireMemory(false, true, false);
memcpy(actual.data(), p, byteSize); memcpy(actual.data(), p, byteSize);
@@ -198,7 +187,7 @@ TEST_F(BufferTest, AcquireMemoryRangeWithExplicit) {
dirty = bufObj->GetDirtyRange(); dirty = bufObj->GetDirtyRange();
ASSERT_EQ(dirty.start, sizeof(Int)); ASSERT_EQ(dirty.start, sizeof(Int));
ASSERT_EQ(dirty.end, sizeof(Int) * 2); ASSERT_EQ(dirty.end, sizeof(Int) * 2);
} }
TEST_F(BufferTest, CopyBufferSubData) { TEST_F(BufferTest, CopyBufferSubData) {
@@ -209,10 +198,10 @@ TEST_F(BufferTest, CopyBufferSubData) {
auto srcObj = glContext.CreateBufferObject(srcNames[0]); auto srcObj = glContext.CreateBufferObject(srcNames[0]);
srcSlot.Bind(srcObj); srcSlot.Bind(srcObj);
Vector<Int> srcData{ 1, 2, 3, 4, 5, 6, 7, 8, 9, 10 }; Vector<Int> srcData{1, 2, 3, 4, 5, 6, 7, 8, 9, 10};
SizeT srcSize = srcData.size() * sizeof(Int); SizeT srcSize = srcData.size() * sizeof(Int);
srcObj->Resize(srcSize); srcObj->Resize(srcSize);
DataPtr srcPtr{ .data = srcData.data(), .size = srcSize }; DataPtr srcPtr{.data = srcData.data(), .size = srcSize};
srcObj->UploadData(srcPtr, 0); srcObj->UploadData(srcPtr, 0);
auto dstNames = glContext.GenBufferNames(1); auto dstNames = glContext.GenBufferNames(1);
@@ -222,22 +211,15 @@ TEST_F(BufferTest, CopyBufferSubData) {
Vector<Int> dstData(15, 0); Vector<Int> dstData(15, 0);
SizeT dstSize = dstData.size() * sizeof(Int); SizeT dstSize = dstData.size() * sizeof(Int);
dstObj->Resize(dstSize); dstObj->Resize(dstSize);
DataPtr dstPtr{ .data = dstData.data(), .size = dstSize }; DataPtr dstPtr{.data = dstData.data(), .size = dstSize};
dstObj->UploadData(dstPtr, 0); dstObj->UploadData(dstPtr, 0);
srcObj->ClearDirty(); srcObj->ClearDirty();
dstObj->ClearDirty(); dstObj->ClearDirty();
dstObj->CopyDataFrom(srcObj, dstObj->CopyDataFrom(srcObj, 2 * sizeof(Int), 5 * sizeof(Int), 4 * sizeof(Int));
2 * sizeof(Int),
5 * sizeof(Int),
4 * sizeof(Int));
Vector<Int> expected{ Vector<Int> expected{0, 0, 0, 0, 0, 3, 4, 5, 6, 0, 0, 0, 0, 0, 0};
0, 0, 0, 0, 0,
3, 4, 5, 6,
0, 0, 0, 0, 0, 0
};
Vector<Int> actual(15); Vector<Int> actual(15);
void* p = dstObj->AcquireMemory(false, true, false); void* p = dstObj->AcquireMemory(false, true, false);
@@ -268,7 +250,7 @@ TEST_F(BufferTest, WriteWhileMapped) {
bufObj->ReleaseMemory(); bufObj->ReleaseMemory();
Vector<Int> expected{ 0, 10, 20, 30, 40, 50, 60, 70, 80, 90 }; Vector<Int> expected{0, 10, 20, 30, 40, 50, 60, 70, 80, 90};
Vector<Int> actual(10); Vector<Int> actual(10);
void* p = bufObj->AcquireMemory(false, true, false); void* p = bufObj->AcquireMemory(false, true, false);
memcpy(actual.data(), p, byteSize); memcpy(actual.data(), p, byteSize);
@@ -286,20 +268,17 @@ TEST_F(BufferTest, PartialUpdate) {
auto bufObj = glContext.CreateBufferObject(bufferNames[0]); auto bufObj = glContext.CreateBufferObject(bufferNames[0]);
slot.Bind(bufObj); slot.Bind(bufObj);
Vector<Int> initData{ 100, 200, 300, 400, 500 }; Vector<Int> initData{100, 200, 300, 400, 500};
SizeT byteSize = initData.size() * sizeof(Int); SizeT byteSize = initData.size() * sizeof(Int);
bufObj->Resize(byteSize); bufObj->Resize(byteSize);
DataPtr ptr{ .data = initData.data(), .size = byteSize }; DataPtr ptr{.data = initData.data(), .size = byteSize};
bufObj->UploadData(ptr, 0); bufObj->UploadData(ptr, 0);
bufObj->ClearDirty(); bufObj->ClearDirty();
Vector<Int> update{ 999, 888 }; Vector<Int> update{999, 888};
bufObj->UploadSubData( bufObj->UploadSubData({(void*)(update.data()), (SizeT)(update.size() * sizeof(Int))}, sizeof(Int));
{ (void*)(update.data()), (SizeT)(update.size() * sizeof(Int)) },
sizeof(Int)
);
Vector<Int> expected{ 100, 999, 888, 400, 500 }; Vector<Int> expected{100, 999, 888, 400, 500};
Vector<Int> actual(5); Vector<Int> actual(5);
void* p = bufObj->AcquireMemory(false, true, false); void* p = bufObj->AcquireMemory(false, true, false);
memcpy(actual.data(), p, byteSize); memcpy(actual.data(), p, byteSize);
@@ -326,9 +305,7 @@ using namespace MobileGL::MG_Impl::GLImpl;
class GeneralBufferTest : public ::testing::Test { class GeneralBufferTest : public ::testing::Test {
protected: protected:
void SetUp() override { void SetUp() override { MG_State::pGLContext = new MG_State::GLState::GLContext(); }
MG_State::pGLContext = new MG_State::GLState::GLContext();
}
GLuint CreateBoundBuffer(GLenum target, GLsizeiptr size, GLenum usage) { GLuint CreateBoundBuffer(GLenum target, GLsizeiptr size, GLenum usage) {
GLuint buffer; GLuint buffer;
@@ -361,7 +338,7 @@ TEST_F(GeneralBufferTest, General_BufferLifecycle) {
TEST_F(GeneralBufferTest, General_BufferDataOperations) { TEST_F(GeneralBufferTest, General_BufferDataOperations) {
GLuint buffer = CreateBoundBuffer(GL_ARRAY_BUFFER, 100, GL_STATIC_DRAW); GLuint buffer = CreateBoundBuffer(GL_ARRAY_BUFFER, 100, GL_STATIC_DRAW);
const char initData[100] = { 0 }; const char initData[100] = {0};
char readBack[100]; char readBack[100];
void* mapped = MapBuffer(GL_ARRAY_BUFFER, GL_READ_ONLY); void* mapped = MapBuffer(GL_ARRAY_BUFFER, GL_READ_ONLY);
ASSERT_NE(mapped, nullptr); ASSERT_NE(mapped, nullptr);
@@ -414,16 +391,14 @@ TEST_F(GeneralBufferTest, General_BufferMapping) {
strcpy((char*)fullMap, " Full mapping test"); strcpy((char*)fullMap, " Full mapping test");
EXPECT_TRUE(UnmapBuffer(GL_ARRAY_BUFFER)); EXPECT_TRUE(UnmapBuffer(GL_ARRAY_BUFFER));
void* partialMap = MapBufferRange(GL_ARRAY_BUFFER, 0, 30, void* partialMap = MapBufferRange(GL_ARRAY_BUFFER, 0, 30, GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT);
GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT);
ASSERT_NE(partialMap, nullptr); ASSERT_NE(partialMap, nullptr);
strcpy((char*)partialMap, "Partial (not valid value)"); strcpy((char*)partialMap, "Partial (not valid value)");
FlushMappedBufferRange(GL_ARRAY_BUFFER, 0, 7); FlushMappedBufferRange(GL_ARRAY_BUFFER, 0, 7);
EXPECT_TRUE(UnmapBuffer(GL_ARRAY_BUFFER)); EXPECT_TRUE(UnmapBuffer(GL_ARRAY_BUFFER));
partialMap = MapBufferRange(GL_ARRAY_BUFFER, 20, 40, partialMap = MapBufferRange(GL_ARRAY_BUFFER, 20, 40, GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT);
GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT);
ASSERT_NE(partialMap, nullptr); ASSERT_NE(partialMap, nullptr);
strcpy((char*)partialMap, ": modified data (not valid value)"); strcpy((char*)partialMap, ": modified data (not valid value)");
@@ -465,8 +440,7 @@ TEST_F(GeneralBufferTest, General_MapFlags) {
EXPECT_TRUE(UnmapBuffer(GL_ARRAY_BUFFER)); EXPECT_TRUE(UnmapBuffer(GL_ARRAY_BUFFER));
void* nosyncMap = MapBufferRange(GL_ARRAY_BUFFER, 0, 100, void* nosyncMap = MapBufferRange(GL_ARRAY_BUFFER, 0, 100, GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT);
GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT);
ASSERT_NE(nosyncMap, nullptr); ASSERT_NE(nosyncMap, nullptr);
memset(nosyncMap, 0xAA, 100); memset(nosyncMap, 0xAA, 100);
EXPECT_TRUE(UnmapBuffer(GL_ARRAY_BUFFER)); EXPECT_TRUE(UnmapBuffer(GL_ARRAY_BUFFER));
@@ -484,37 +458,33 @@ TEST_F(GeneralBufferTest, General_GeneralTest_1) {
BindBuffer(GL_ARRAY_BUFFER, vbo); BindBuffer(GL_ARRAY_BUFFER, vbo);
BufferData(GL_ARRAY_BUFFER, 64, nullptr, GL_STATIC_DRAW); BufferData(GL_ARRAY_BUFFER, 64, nullptr, GL_STATIC_DRAW);
const float vertexData[] = { 0.1f, 0.2f, 0.3f, 1.0f }; const float vertexData[] = {0.1f, 0.2f, 0.3f, 1.0f};
BufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertexData), vertexData); BufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertexData), vertexData);
BindBuffer(GL_UNIFORM_BUFFER, ibo); BindBuffer(GL_UNIFORM_BUFFER, ibo);
const uint16_t indexData[] = { 0, 1, 2, 3, 0 }; const uint16_t indexData[] = {0, 1, 2, 3, 0};
BufferData(GL_UNIFORM_BUFFER, sizeof(indexData), indexData, GL_STATIC_DRAW); BufferData(GL_UNIFORM_BUFFER, sizeof(indexData), indexData, GL_STATIC_DRAW);
const uint16_t newIndices[] = { 4, 5 }; const uint16_t newIndices[] = {4, 5};
BufferSubData(GL_UNIFORM_BUFFER, 2 * sizeof(uint16_t), BufferSubData(GL_UNIFORM_BUFFER, 2 * sizeof(uint16_t), sizeof(newIndices), newIndices);
sizeof(newIndices), newIndices);
BindBuffer(GL_COPY_READ_BUFFER, staging); BindBuffer(GL_COPY_READ_BUFFER, staging);
const char stagingData[] = "StagingBufferData"; const char stagingData[] = "StagingBufferData";
BufferData(GL_COPY_READ_BUFFER, sizeof(stagingData), stagingData, GL_STREAM_COPY); BufferData(GL_COPY_READ_BUFFER, sizeof(stagingData), stagingData, GL_STREAM_COPY);
CopyBufferSubData(GL_COPY_READ_BUFFER, GL_ARRAY_BUFFER, CopyBufferSubData(GL_COPY_READ_BUFFER, GL_ARRAY_BUFFER, 0, 40, sizeof(stagingData));
0, 40, sizeof(stagingData));
BindBuffer(GL_UNIFORM_BUFFER, ibo); BindBuffer(GL_UNIFORM_BUFFER, ibo);
void* fullMap = MapBuffer(GL_UNIFORM_BUFFER, GL_READ_WRITE); void* fullMap = MapBuffer(GL_UNIFORM_BUFFER, GL_READ_WRITE);
ASSERT_NE(fullMap, nullptr); ASSERT_NE(fullMap, nullptr);
uint16_t* indices = static_cast<uint16_t*>(fullMap); uint16_t* indices = static_cast<uint16_t*>(fullMap);
indices[0] = 10; indices[0] = 10;
EXPECT_TRUE(UnmapBuffer(GL_UNIFORM_BUFFER)); EXPECT_TRUE(UnmapBuffer(GL_UNIFORM_BUFFER));
BindBuffer(GL_ARRAY_BUFFER, vbo); BindBuffer(GL_ARRAY_BUFFER, vbo);
void* partialMap = MapBufferRange(GL_ARRAY_BUFFER, 20, 8, void* partialMap = MapBufferRange(GL_ARRAY_BUFFER, 20, 8, GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT);
GL_MAP_WRITE_BIT |
GL_MAP_FLUSH_EXPLICIT_BIT);
ASSERT_NE(partialMap, nullptr); ASSERT_NE(partialMap, nullptr);
const char partialWriteData[] = "PARTIAL"; // 7 chars + '\0' = 8 bytes const char partialWriteData[] = "PARTIAL"; // 7 chars + '\0' = 8 bytes
@@ -552,8 +522,8 @@ TEST_F(GeneralBufferTest, General_GeneralTest_1) {
GLenum err = GetError(); GLenum err = GetError();
EXPECT_EQ(err, GL_INVALID_OPERATION); EXPECT_EQ(err, GL_INVALID_OPERATION);
GLuint toDelete[] = { vbo, ibo }; GLuint toDelete[] = {vbo, ibo};
DeleteBuffers(2, toDelete); DeleteBuffers(2, toDelete);
EXPECT_EQ(GetError(), GL_NO_ERROR); EXPECT_EQ(GetError(), GL_NO_ERROR);
} }
MobileGL/MG_Test/Program/ProgramTest.cpp
+43 -63
View File
@@ -8,13 +8,9 @@ using namespace MobileGL::MG_Impl::GLImpl;
class ProgramTest : public ::testing::Test { class ProgramTest : public ::testing::Test {
protected: protected:
void SetUp() override { void SetUp() override { MG_State::pGLContext = new MG_State::GLState::GLContext(); }
MG_State::pGLContext = new MG_State::GLState::GLContext();
}
void TearDown() override { void TearDown() override { delete MG_State::pGLContext; }
delete MG_State::pGLContext;
}
}; };
TEST_F(ProgramTest, Sanity) { TEST_F(ProgramTest, Sanity) {
@@ -94,7 +90,6 @@ void main() {
fragColor = vec4(OutColor, float(intVal)); fragColor = vec4(OutColor, float(intVal));
})"; })";
TEST_F(ProgramTest, CompileVertex) { TEST_F(ProgramTest, CompileVertex) {
GLuint vs = CreateShader(GL_VERTEX_SHADER); GLuint vs = CreateShader(GL_VERTEX_SHADER);
ShaderSource(vs, 1, &vsSrc, NULL); ShaderSource(vs, 1, &vsSrc, NULL);
@@ -215,32 +210,24 @@ TEST_F(ProgramTest, UniformMatrixFunctions) {
// Test UniformMatrix2fv // Test UniformMatrix2fv
auto locProjMat = GetUniformLocation(program, "ProjMat"); auto locProjMat = GetUniformLocation(program, "ProjMat");
ASSERT_NE(locProjMat, -1); ASSERT_NE(locProjMat, -1);
// 4x4 matrix (16 elements) - identity matrix // 4x4 matrix (16 elements) - identity matrix
GLfloat matrix4x4[16] = { GLfloat matrix4x4[16] = {1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f};
0.0f, 1.0f, 0.0f, 0.0f,
0.0f, 0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 0.0f, 1.0f
};
// Test UniformMatrix4fv with count = 1 and transpose = GL_FALSE // Test UniformMatrix4fv with count = 1 and transpose = GL_FALSE
UniformMatrix4fv(locProjMat, 1, GL_FALSE, matrix4x4); UniformMatrix4fv(locProjMat, 1, GL_FALSE, matrix4x4);
// Test UniformMatrix4fv with count = 1 and transpose = GL_TRUE // Test UniformMatrix4fv with count = 1 and transpose = GL_TRUE
UniformMatrix4fv(locProjMat, 1, GL_TRUE, matrix4x4); UniformMatrix4fv(locProjMat, 1, GL_TRUE, matrix4x4);
// Test with a non-identity matrix // Test with a non-identity matrix
GLfloat nonIdentityMatrix[16] = { GLfloat nonIdentityMatrix[16] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f,
1.0f, 2.0f, 3.0f, 4.0f, 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f};
5.0f, 6.0f, 7.0f, 8.0f,
9.0f, 10.0f, 11.0f, 12.0f,
13.0f, 14.0f, 15.0f, 16.0f
};
// Test with transpose = GL_FALSE // Test with transpose = GL_FALSE
UniformMatrix4fv(locProjMat, 1, GL_FALSE, nonIdentityMatrix); UniformMatrix4fv(locProjMat, 1, GL_FALSE, nonIdentityMatrix);
// Test with transpose = GL_TRUE // Test with transpose = GL_TRUE
UniformMatrix4fv(locProjMat, 1, GL_TRUE, nonIdentityMatrix); UniformMatrix4fv(locProjMat, 1, GL_TRUE, nonIdentityMatrix);
} }
@@ -288,8 +275,8 @@ TEST_F(ProgramTest, UniformMatrixTranspose) {
// [1 3] // [1 3]
// [2 4] // [2 4]
GLfloat matrix2x2[4] = { GLfloat matrix2x2[4] = {
1.0f, 2.0f, // First column 1.0f, 2.0f, // First column
3.0f, 4.0f // Second column 3.0f, 4.0f // Second column
}; };
// Expected values when transpose = GL_FALSE (no transpose): // Expected values when transpose = GL_FALSE (no transpose):
@@ -318,7 +305,7 @@ TEST_F(ProgramTest, UniformMatrixTranspose) {
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
EXPECT_FLOAT_EQ(result2x2_transpose[i], expected2x2_transpose[i]); EXPECT_FLOAT_EQ(result2x2_transpose[i], expected2x2_transpose[i]);
} }
// Test 3x3 matrix transpose // Test 3x3 matrix transpose
auto locMat3 = GetUniformLocation(program, "TestMat3"); auto locMat3 = GetUniformLocation(program, "TestMat3");
ASSERT_NE(locMat3, -1); ASSERT_NE(locMat3, -1);
@@ -327,9 +314,9 @@ TEST_F(ProgramTest, UniformMatrixTranspose) {
// [2 5 8] // [2 5 8]
// [3 6 9] // [3 6 9]
GLfloat matrix3x3[9] = { GLfloat matrix3x3[9] = {
1.0f, 2.0f, 3.0f, // First column 1.0f, 2.0f, 3.0f, // First column
4.0f, 5.0f, 6.0f, // Second column 4.0f, 5.0f, 6.0f, // Second column
7.0f, 8.0f, 9.0f // Third column 7.0f, 8.0f, 9.0f // Third column
}; };
// Expected values when transpose = GL_FALSE (no transpose): // Expected values when transpose = GL_FALSE (no transpose):
@@ -360,40 +347,40 @@ TEST_F(ProgramTest, UniformMatrixTranspose) {
for (int i = 0; i < 9; i++) { for (int i = 0; i < 9; i++) {
EXPECT_FLOAT_EQ(result3x3_transpose[i], expected3x3_transpose[i]); EXPECT_FLOAT_EQ(result3x3_transpose[i], expected3x3_transpose[i]);
} }
// Test 4x4 matrix transpose // Test 4x4 matrix transpose
auto locProjMat = GetUniformLocation(program, "ProjMat"); auto locProjMat = GetUniformLocation(program, "ProjMat");
ASSERT_NE(locProjMat, -1); ASSERT_NE(locProjMat, -1);
// Test matrix (column-major as expected by OpenGL): // Test matrix (column-major as expected by OpenGL):
// [1 5 9 13] // [1 5 9 13]
// [2 6 10 14] // [2 6 10 14]
// [3 7 11 15] // [3 7 11 15]
// [4 8 12 16] // [4 8 12 16]
GLfloat matrix4x4[16] = { GLfloat matrix4x4[16] = {
1.0f, 2.0f, 3.0f, 4.0f, // First column 1.0f, 2.0f, 3.0f, 4.0f, // First column
5.0f, 6.0f, 7.0f, 8.0f, // Second column 5.0f, 6.0f, 7.0f, 8.0f, // Second column
9.0f, 10.0f, 11.0f, 12.0f, // Third column 9.0f, 10.0f, 11.0f, 12.0f, // Third column
13.0f, 14.0f, 15.0f, 16.0f // Fourth column 13.0f, 14.0f, 15.0f, 16.0f // Fourth column
}; };
// Expected values when transpose = GL_FALSE (no transpose): // Expected values when transpose = GL_FALSE (no transpose):
// [1 5 9 13] // [1 5 9 13]
// [2 6 10 14] // [2 6 10 14]
// [3 7 11 15] // [3 7 11 15]
// [4 8 12 16] // [4 8 12 16]
GLfloat expected4x4_no_transpose[16] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f, GLfloat expected4x4_no_transpose[16] = {1.0f, 2.0f, 3.0f, 4.0f, 5.0f, 6.0f, 7.0f, 8.0f,
9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f}; 9.0f, 10.0f, 11.0f, 12.0f, 13.0f, 14.0f, 15.0f, 16.0f};
// Expected values when transpose = GL_TRUE (transposed): // Expected values when transpose = GL_TRUE (transposed):
// [1 2 3 4] // [1 2 3 4]
// [5 6 7 8] // [5 6 7 8]
// [9 10 11 12] // [9 10 11 12]
// [13 14 15 16] // [13 14 15 16]
// Stored in column-major order // Stored in column-major order
GLfloat expected4x4_transpose[16] = {1.0f, 5.0f, 9.0f, 13.0f, 2.0f, 6.0f, 10.0f, 14.0f, GLfloat expected4x4_transpose[16] = {1.0f, 5.0f, 9.0f, 13.0f, 2.0f, 6.0f, 10.0f, 14.0f,
3.0f, 7.0f, 11.0f, 15.0f, 4.0f, 8.0f, 12.0f, 16.0f}; 3.0f, 7.0f, 11.0f, 15.0f, 4.0f, 8.0f, 12.0f, 16.0f};
// Test with transpose = GL_FALSE // Test with transpose = GL_FALSE
UniformMatrix4fv(locProjMat, 1, GL_FALSE, matrix4x4); UniformMatrix4fv(locProjMat, 1, GL_FALSE, matrix4x4);
GLfloat result4x4_no_transpose[16]; GLfloat result4x4_no_transpose[16];
@@ -401,7 +388,7 @@ TEST_F(ProgramTest, UniformMatrixTranspose) {
for (int i = 0; i < 16; i++) { for (int i = 0; i < 16; i++) {
EXPECT_FLOAT_EQ(result4x4_no_transpose[i], expected4x4_no_transpose[i]); EXPECT_FLOAT_EQ(result4x4_no_transpose[i], expected4x4_no_transpose[i]);
} }
// Test with transpose = GL_TRUE // Test with transpose = GL_TRUE
UniformMatrix4fv(locProjMat, 1, GL_TRUE, matrix4x4); UniformMatrix4fv(locProjMat, 1, GL_TRUE, matrix4x4);
GLfloat result4x4_transpose[16]; GLfloat result4x4_transpose[16];
@@ -444,29 +431,25 @@ TEST_F(ProgramTest, UniformLocationGaps) {
// Test that uniform locations are correctly assigned even with gaps // Test that uniform locations are correctly assigned even with gaps
// ProjMat is at location 0 // ProjMat is at location 0
ASSERT_EQ(GetUniformLocation(program, "ProjMat"), 0); ASSERT_EQ(GetUniformLocation(program, "ProjMat"), 0);
// TestMat3 is at location 10 (gap from 1-9) // TestMat3 is at location 10 (gap from 1-9)
ASSERT_EQ(GetUniformLocation(program, "TestMat3"), 10); ASSERT_EQ(GetUniformLocation(program, "TestMat3"), 10);
// TestMat2 is at location 20 (gap from 11-19) // TestMat2 is at location 20 (gap from 11-19)
ASSERT_EQ(GetUniformLocation(program, "TestMat2"), 20); ASSERT_EQ(GetUniformLocation(program, "TestMat2"), 20);
// Gray is at location 1 (no gap) // Gray is at location 1 (no gap)
ASSERT_EQ(GetUniformLocation(program, "Gray"), 1); ASSERT_EQ(GetUniformLocation(program, "Gray"), 1);
// Saturation is at location 6 (gap from 2-5) // Saturation is at location 6 (gap from 2-5)
ASSERT_EQ(GetUniformLocation(program, "Saturation"), 6); ASSERT_EQ(GetUniformLocation(program, "Saturation"), 6);
// Verify that locations in gaps correctly return -1 // Verify that locations in gaps correctly return -1
ASSERT_EQ(GetUniformLocation(program, "NonExistentUniform"), -1); ASSERT_EQ(GetUniformLocation(program, "NonExistentUniform"), -1);
// Test uniform operations on locations with gaps // Test uniform operations on locations with gaps
GLfloat matrix3[9] = { GLfloat matrix3[9] = {1.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f};
1.0f, 0.0f, 0.0f,
0.0f, 1.0f, 0.0f,
0.0f, 0.0f, 1.0f
};
// Test setting and getting uniform at location 10 (TestMat3) // Test setting and getting uniform at location 10 (TestMat3)
UniformMatrix3fv(10, 1, GL_FALSE, matrix3); UniformMatrix3fv(10, 1, GL_FALSE, matrix3);
GLfloat result[9]; GLfloat result[9];
@@ -474,19 +457,16 @@ TEST_F(ProgramTest, UniformLocationGaps) {
for (int i = 0; i < 9; i++) { for (int i = 0; i < 9; i++) {
EXPECT_FLOAT_EQ(result[i], matrix3[i]); EXPECT_FLOAT_EQ(result[i], matrix3[i]);
} }
// Test setting and getting uniform at location 20 (TestMat2) // Test setting and getting uniform at location 20 (TestMat2)
GLfloat matrix2[4] = { GLfloat matrix2[4] = {1.0f, 0.0f, 0.0f, 1.0f};
1.0f, 0.0f,
0.0f, 1.0f
};
UniformMatrix2fv(20, 1, GL_FALSE, matrix2); UniformMatrix2fv(20, 1, GL_FALSE, matrix2);
GLfloat result2[4]; GLfloat result2[4];
GetUniformfv(program, 20, result2); GetUniformfv(program, 20, result2);
for (int i = 0; i < 4; i++) { for (int i = 0; i < 4; i++) {
EXPECT_FLOAT_EQ(result2[i], matrix2[i]); EXPECT_FLOAT_EQ(result2[i], matrix2[i]);
} }
// Test that accessing a gap location (e.g., 5) doesn't cause issues // Test that accessing a gap location (e.g., 5) doesn't cause issues
// This should not crash or cause undefined behavior // This should not crash or cause undefined behavior
Uniform1i(5, 114514); // Just to make sure we don't crash Uniform1i(5, 114514); // Just to make sure we don't crash
MobileGL/MG_Test/Program/ProgramUtilTest.cpp
+20 -50
View File
@@ -41,10 +41,7 @@ void main(){
TEST_F(ProgramUtilTest, CompileSimpleVertexShader) { TEST_F(ProgramUtilTest, CompileSimpleVertexShader) {
using namespace MG_Util::ShaderTranspiler; using namespace MG_Util::ShaderTranspiler;
ShaderAttrib attrib { ShaderAttrib attrib{.shaderType = GL_VERTEX_SHADER, .sourceStr = vs};
.shaderType = GL_VERTEX_SHADER,
.sourceStr = vs
};
auto res = ShaderCompiler::CompileShader(attrib); auto res = ShaderCompiler::CompileShader(attrib);
if (!res) { if (!res) {
ASSERT_NE(res.error().errc, 0); ASSERT_NE(res.error().errc, 0);
@@ -93,10 +90,7 @@ void main() {
TEST_F(ProgramUtilTest, CompileSimpleFragmentShader) { TEST_F(ProgramUtilTest, CompileSimpleFragmentShader) {
using namespace MG_Util::ShaderTranspiler; using namespace MG_Util::ShaderTranspiler;
ShaderAttrib attrib { ShaderAttrib attrib{.shaderType = GL_FRAGMENT_SHADER, .sourceStr = fs};
.shaderType = GL_FRAGMENT_SHADER,
.sourceStr = fs
};
auto res = ShaderCompiler::CompileShader(attrib); auto res = ShaderCompiler::CompileShader(attrib);
if (!res) { if (!res) {
ASSERT_NE(res.error().errc, 0); ASSERT_NE(res.error().errc, 0);
@@ -122,20 +116,15 @@ void main() {
TEST_F(ProgramUtilTest, CompileFragmentShaderWithDiscard) { TEST_F(ProgramUtilTest, CompileFragmentShaderWithDiscard) {
using namespace MG_Util::ShaderTranspiler; using namespace MG_Util::ShaderTranspiler;
ShaderAttrib attrib { ShaderAttrib attrib{.shaderType = GL_FRAGMENT_SHADER, .sourceStr = position_color_fsh};
.shaderType = GL_FRAGMENT_SHADER,
.sourceStr = position_color_fsh
};
auto res = ShaderCompiler::CompileShader(attrib); auto res = ShaderCompiler::CompileShader(attrib);
if (!res) { if (!res) {
ASSERT_NE(res.error().errc, 0); ASSERT_NE(res.error().errc, 0);
FAIL() << "errc: " << res.error().errc << "\nlog: " << res.error().log; FAIL() << "errc: " << res.error().errc << "\nlog: " << res.error().log;
} }
ProgramAttrib programAttrib { ProgramAttrib programAttrib{// .shaderTypes = { GL_FRAGMENT_SHADER },
// .shaderTypes = { GL_FRAGMENT_SHADER }, .shaders = {res.value()}};
.shaders = { res.value() }
};
auto program_res = ShaderCompiler::LinkProgram(programAttrib); auto program_res = ShaderCompiler::LinkProgram(programAttrib);
if (!program_res) { if (!program_res) {
@@ -145,8 +134,8 @@ TEST_F(ProgramUtilTest, CompileFragmentShaderWithDiscard) {
auto program = program_res.value(); auto program = program_res.value();
ProgramBinaryAttrib binaryAttrib { ProgramBinaryAttrib binaryAttrib{
.shaderTypes = { GL_FRAGMENT_SHADER }, .shaderTypes = {GL_FRAGMENT_SHADER},
.program = *program, .program = *program,
}; };
auto bin_res = ShaderCompiler::GetSpirvBinaryFromProgram(binaryAttrib); auto bin_res = ShaderCompiler::GetSpirvBinaryFromProgram(binaryAttrib);
@@ -196,11 +185,8 @@ void main(){
TEST_F(ProgramUtilTest, CompileVertexShaderWithLocation) { TEST_F(ProgramUtilTest, CompileVertexShaderWithLocation) {
using namespace MG_Util::ShaderTranspiler; using namespace MG_Util::ShaderTranspiler;
ShaderAttrib attrib { ShaderAttrib attrib{
.shaderType = GL_VERTEX_SHADER, .shaderType = GL_VERTEX_SHADER, .sourceStr = vs_location, .flags = ShaderCompileBits::CompileForOpenGL};
.sourceStr = vs_location,
.flags = ShaderCompileBits::CompileForOpenGL
};
auto res = ShaderCompiler::CompileShader(attrib); auto res = ShaderCompiler::CompileShader(attrib);
if (!res) { if (!res) {
ASSERT_NE(res.error().errc, 0); ASSERT_NE(res.error().errc, 0);
@@ -224,30 +210,22 @@ TEST_F(ProgramUtilTest, CompileVertexShaderWithLocation) {
TEST_F(ProgramUtilTest, CompileAndLinkProgram) { TEST_F(ProgramUtilTest, CompileAndLinkProgram) {
using namespace MG_Util::ShaderTranspiler; using namespace MG_Util::ShaderTranspiler;
ShaderAttrib vs_attrib { ShaderAttrib vs_attrib{.shaderType = GL_VERTEX_SHADER, .sourceStr = vs};
.shaderType = GL_VERTEX_SHADER,
.sourceStr = vs
};
auto vs_res = ShaderCompiler::CompileShader(vs_attrib); auto vs_res = ShaderCompiler::CompileShader(vs_attrib);
if (!vs_res) { if (!vs_res) {
ASSERT_NE(vs_res.error().errc, 0); ASSERT_NE(vs_res.error().errc, 0);
FAIL() << "errc: " << vs_res.error().errc << "\nlog: " << vs_res.error().log; FAIL() << "errc: " << vs_res.error().errc << "\nlog: " << vs_res.error().log;
} }
ShaderAttrib fs_attrib { ShaderAttrib fs_attrib{.shaderType = GL_FRAGMENT_SHADER, .sourceStr = fs};
.shaderType = GL_FRAGMENT_SHADER,
.sourceStr = fs
};
auto fs_res = ShaderCompiler::CompileShader(fs_attrib); auto fs_res = ShaderCompiler::CompileShader(fs_attrib);
if (!fs_res) { if (!fs_res) {
ASSERT_NE(fs_res.error().errc, 0); ASSERT_NE(fs_res.error().errc, 0);
FAIL() << "errc: " << fs_res.error().errc << "\nlog: " << fs_res.error().log; FAIL() << "errc: " << fs_res.error().errc << "\nlog: " << fs_res.error().log;
} }
ProgramAttrib programAttrib { ProgramAttrib programAttrib{// .shaderTypes = { GL_VERTEX_SHADER, GL_FRAGMENT_SHADER },
// .shaderTypes = { GL_VERTEX_SHADER, GL_FRAGMENT_SHADER }, .shaders = {vs_res.value(), fs_res.value()}};
.shaders = { vs_res.value(), fs_res.value() }
};
auto program_res = ShaderCompiler::LinkProgram(programAttrib); auto program_res = ShaderCompiler::LinkProgram(programAttrib);
if (!program_res) { if (!program_res) {
@@ -258,30 +236,22 @@ TEST_F(ProgramUtilTest, CompileAndLinkProgram) {
TEST_F(ProgramUtilTest, DecompProgram) { TEST_F(ProgramUtilTest, DecompProgram) {
using namespace MG_Util::ShaderTranspiler; using namespace MG_Util::ShaderTranspiler;
ShaderAttrib vs_attrib { ShaderAttrib vs_attrib{.shaderType = GL_VERTEX_SHADER, .sourceStr = vs};
.shaderType = GL_VERTEX_SHADER,
.sourceStr = vs
};
auto vs_res = ShaderCompiler::CompileShader(vs_attrib); auto vs_res = ShaderCompiler::CompileShader(vs_attrib);
if (!vs_res) { if (!vs_res) {
ASSERT_NE(vs_res.error().errc, 0); ASSERT_NE(vs_res.error().errc, 0);
FAIL() << "errc: " << vs_res.error().errc << "\nlog: " << vs_res.error().log; FAIL() << "errc: " << vs_res.error().errc << "\nlog: " << vs_res.error().log;
} }
ShaderAttrib fs_attrib { ShaderAttrib fs_attrib{.shaderType = GL_FRAGMENT_SHADER, .sourceStr = fs};
.shaderType = GL_FRAGMENT_SHADER,
.sourceStr = fs
};
auto fs_res = ShaderCompiler::CompileShader(fs_attrib); auto fs_res = ShaderCompiler::CompileShader(fs_attrib);
if (!fs_res) { if (!fs_res) {
ASSERT_NE(fs_res.error().errc, 0); ASSERT_NE(fs_res.error().errc, 0);
FAIL() << "errc: " << fs_res.error().errc << "\nlog: " << fs_res.error().log; FAIL() << "errc: " << fs_res.error().errc << "\nlog: " << fs_res.error().log;
} }
ProgramAttrib programAttrib { ProgramAttrib programAttrib{// .shaderTypes = { GL_VERTEX_SHADER, GL_FRAGMENT_SHADER },
// .shaderTypes = { GL_VERTEX_SHADER, GL_FRAGMENT_SHADER }, .shaders = {vs_res.value(), fs_res.value()}};
.shaders = { vs_res.value(), fs_res.value() }
};
auto program_res = ShaderCompiler::LinkProgram(programAttrib); auto program_res = ShaderCompiler::LinkProgram(programAttrib);
if (!program_res) { if (!program_res) {
@@ -289,8 +259,8 @@ TEST_F(ProgramUtilTest, DecompProgram) {
FAIL() << "errc: " << program_res.error().errc << "\nlog: " << program_res.error().log; FAIL() << "errc: " << program_res.error().errc << "\nlog: " << program_res.error().log;
} }
ProgramBinaryAttrib binaryAttrib { ProgramBinaryAttrib binaryAttrib{
.shaderTypes = { GL_VERTEX_SHADER, GL_FRAGMENT_SHADER }, .shaderTypes = {GL_VERTEX_SHADER, GL_FRAGMENT_SHADER},
.program = *program_res.value(), .program = *program_res.value(),
}; };
auto bin_res = ShaderCompiler::GetSpirvBinaryFromProgram(binaryAttrib); auto bin_res = ShaderCompiler::GetSpirvBinaryFromProgram(binaryAttrib);
@@ -322,7 +292,7 @@ TEST_F(ProgramUtilTest, DecompProgram) {
for (size_t i = 0; i < vs_outputs.size(); ++i) { for (size_t i = 0; i < vs_outputs.size(); ++i) {
EXPECT_EQ(vs_outputs[i].location, fs_inputs[i].location); EXPECT_EQ(vs_outputs[i].location, fs_inputs[i].location);
} }
auto vs_uniforms = sessions[0].GetShaderInterface(SPVC_RESOURCE_TYPE_GL_PLAIN_UNIFORM); auto vs_uniforms = sessions[0].GetShaderInterface(SPVC_RESOURCE_TYPE_GL_PLAIN_UNIFORM);
auto fs_uniforms = sessions[1].GetShaderInterface(SPVC_RESOURCE_TYPE_GL_PLAIN_UNIFORM); auto fs_uniforms = sessions[1].GetShaderInterface(SPVC_RESOURCE_TYPE_GL_PLAIN_UNIFORM);
MobileGL/MG_Test/SanityTest.cpp
+4 -4
View File
@@ -1,8 +1,8 @@
#include <gtest/gtest.h> #include <gtest/gtest.h>
TEST(Sanity, BasicAssertions) { TEST(Sanity, BasicAssertions) {
// Expect two strings not to be equal. // Expect two strings not to be equal.
EXPECT_STRNE("hello", "world"); EXPECT_STRNE("hello", "world");
// Expect equality. // Expect equality.
EXPECT_EQ(7 * 6, 42); EXPECT_EQ(7 * 6, 42);
} }
MobileGL/MG_Util/Converters/SPIRVCrossToGL/SpvcTypeConverter.cpp
+85 -80
View File
@@ -19,106 +19,111 @@ namespace MobileGL {
if (matCol > 1) { if (matCol > 1) {
switch (baseType) { switch (baseType) {
case GL_FLOAT: case GL_FLOAT:
if (vecSize == 4 && matCol == 4) return GL_FLOAT_MAT4; if (vecSize == 4 && matCol == 4) return GL_FLOAT_MAT4;
if (vecSize == 3 && matCol == 3) return GL_FLOAT_MAT3; if (vecSize == 3 && matCol == 3) return GL_FLOAT_MAT3;
if (vecSize == 2 && matCol == 2) return GL_FLOAT_MAT2; if (vecSize == 2 && matCol == 2) return GL_FLOAT_MAT2;
if (vecSize == 2 && matCol == 3) return GL_FLOAT_MAT3x2; if (vecSize == 2 && matCol == 3) return GL_FLOAT_MAT3x2;
if (vecSize == 2 && matCol == 4) return GL_FLOAT_MAT4x2; if (vecSize == 2 && matCol == 4) return GL_FLOAT_MAT4x2;
if (vecSize == 3 && matCol == 2) return GL_FLOAT_MAT2x3; if (vecSize == 3 && matCol == 2) return GL_FLOAT_MAT2x3;
if (vecSize == 3 && matCol == 4) return GL_FLOAT_MAT4x3; if (vecSize == 3 && matCol == 4) return GL_FLOAT_MAT4x3;
if (vecSize == 4 && matCol == 2) return GL_FLOAT_MAT2x4; if (vecSize == 4 && matCol == 2) return GL_FLOAT_MAT2x4;
if (vecSize == 4 && matCol == 3) return GL_FLOAT_MAT3x4; if (vecSize == 4 && matCol == 3) return GL_FLOAT_MAT3x4;
break; break;
case GL_DOUBLE: case GL_DOUBLE:
if (vecSize == 4 && matCol == 4) return GL_DOUBLE_MAT4; if (vecSize == 4 && matCol == 4) return GL_DOUBLE_MAT4;
if (vecSize == 3 && matCol == 3) return GL_DOUBLE_MAT3; if (vecSize == 3 && matCol == 3) return GL_DOUBLE_MAT3;
if (vecSize == 2 && matCol == 2) return GL_DOUBLE_MAT2; if (vecSize == 2 && matCol == 2) return GL_DOUBLE_MAT2;
if (vecSize == 2 && matCol == 3) return GL_DOUBLE_MAT3x2; if (vecSize == 2 && matCol == 3) return GL_DOUBLE_MAT3x2;
if (vecSize == 2 && matCol == 4) return GL_DOUBLE_MAT4x2; if (vecSize == 2 && matCol == 4) return GL_DOUBLE_MAT4x2;
if (vecSize == 3 && matCol == 2) return GL_DOUBLE_MAT2x3; if (vecSize == 3 && matCol == 2) return GL_DOUBLE_MAT2x3;
if (vecSize == 3 && matCol == 4) return GL_DOUBLE_MAT4x3; if (vecSize == 3 && matCol == 4) return GL_DOUBLE_MAT4x3;
if (vecSize == 4 && matCol == 2) return GL_DOUBLE_MAT2x4; if (vecSize == 4 && matCol == 2) return GL_DOUBLE_MAT2x4;
if (vecSize == 4 && matCol == 3) return GL_DOUBLE_MAT3x4; if (vecSize == 4 && matCol == 3) return GL_DOUBLE_MAT3x4;
break; break;
default: default:
return GL_FALSE; return GL_FALSE;
} }
} }
else if (matCol == 1) { else if (matCol == 1) {
switch (baseType) { switch (baseType) {
case GL_BOOL: case GL_BOOL:
switch (vecSize) { switch (vecSize) {
case 4: return GL_BOOL_VEC4; case 4:
case 3: return GL_BOOL_VEC3; return GL_BOOL_VEC4;
case 2: return GL_BOOL_VEC2; case 3:
} return GL_BOOL_VEC3;
case GL_FLOAT: case 2:
return GL_FLOAT_VEC2 + (vecSize - 2); // GL_FLOAT_VEC* is contiguous return GL_BOOL_VEC2;
case GL_DOUBLE: }
switch (vecSize) { case GL_FLOAT:
case 4: return GL_DOUBLE_VEC4; return GL_FLOAT_VEC2 + (vecSize - 2); // GL_FLOAT_VEC* is contiguous
case 3: return GL_DOUBLE_VEC3; case GL_DOUBLE:
case 2: return GL_DOUBLE_VEC2; switch (vecSize) {
} case 4:
break; return GL_DOUBLE_VEC4;
case GL_INT: case 3:
return GL_INT_VEC2 + (vecSize - 2); // GL_INT_VEC* is contiguous return GL_DOUBLE_VEC3;
case GL_UNSIGNED_INT: case 2:
return GL_UNSIGNED_INT_VEC2 + (vecSize - 2); // GL_UNSIGNED_INT_VEC* is contiguous return GL_DOUBLE_VEC2;
}
break;
case GL_INT:
return GL_INT_VEC2 + (vecSize - 2); // GL_INT_VEC* is contiguous
case GL_UNSIGNED_INT:
return GL_UNSIGNED_INT_VEC2 + (vecSize - 2); // GL_UNSIGNED_INT_VEC* is contiguous
} }
} }
return GL_FALSE; return GL_FALSE;
} }
GLenum ConvertSpvcTypeToGLEnum(const ShaderTranspiler::SpvcType& spvcType) { GLenum ConvertSpvcTypeToGLEnum(const ShaderTranspiler::SpvcType& spvcType) {
switch (spvcType.basetype) { switch (spvcType.basetype) {
case SPVC_BASETYPE_BOOLEAN: case SPVC_BASETYPE_BOOLEAN:
return ConvertBaseTypeToType(GL_BOOL, spvcType.vectorSize, spvcType.matCol); return ConvertBaseTypeToType(GL_BOOL, spvcType.vectorSize, spvcType.matCol);
case SPVC_BASETYPE_INT8: case SPVC_BASETYPE_INT8:
return ConvertBaseTypeToType(GL_BYTE, spvcType.vectorSize, spvcType.matCol); return ConvertBaseTypeToType(GL_BYTE, spvcType.vectorSize, spvcType.matCol);
case SPVC_BASETYPE_INT16: case SPVC_BASETYPE_INT16:
case SPVC_BASETYPE_INT32: case SPVC_BASETYPE_INT32:
case SPVC_BASETYPE_INT64: case SPVC_BASETYPE_INT64:
return ConvertBaseTypeToType(GL_INT, spvcType.vectorSize, spvcType.matCol); return ConvertBaseTypeToType(GL_INT, spvcType.vectorSize, spvcType.matCol);
case SPVC_BASETYPE_UINT8: case SPVC_BASETYPE_UINT8:
return ConvertBaseTypeToType(GL_UNSIGNED_BYTE, spvcType.vectorSize, spvcType.matCol); return ConvertBaseTypeToType(GL_UNSIGNED_BYTE, spvcType.vectorSize, spvcType.matCol);
case SPVC_BASETYPE_UINT16: case SPVC_BASETYPE_UINT16:
case SPVC_BASETYPE_UINT32: case SPVC_BASETYPE_UINT32:
case SPVC_BASETYPE_UINT64: case SPVC_BASETYPE_UINT64:
return ConvertBaseTypeToType(GL_UNSIGNED_INT, spvcType.vectorSize, spvcType.matCol); return ConvertBaseTypeToType(GL_UNSIGNED_INT, spvcType.vectorSize, spvcType.matCol);
case SPVC_BASETYPE_ATOMIC_COUNTER: case SPVC_BASETYPE_ATOMIC_COUNTER:
return GL_UNSIGNED_INT_ATOMIC_COUNTER; return GL_UNSIGNED_INT_ATOMIC_COUNTER;
case SPVC_BASETYPE_FP16: case SPVC_BASETYPE_FP16:
case SPVC_BASETYPE_FP32: case SPVC_BASETYPE_FP32:
return ConvertBaseTypeToType(GL_FLOAT, spvcType.vectorSize, spvcType.matCol); return ConvertBaseTypeToType(GL_FLOAT, spvcType.vectorSize, spvcType.matCol);
case SPVC_BASETYPE_FP64: case SPVC_BASETYPE_FP64:
return ConvertBaseTypeToType(GL_DOUBLE, spvcType.vectorSize, spvcType.matCol); return ConvertBaseTypeToType(GL_DOUBLE, spvcType.vectorSize, spvcType.matCol);
// FIXME: likely wrong conversions! // FIXME: likely wrong conversions!
case SPVC_BASETYPE_IMAGE: case SPVC_BASETYPE_IMAGE:
return GL_IMAGE_2D; return GL_IMAGE_2D;
case SPVC_BASETYPE_SAMPLED_IMAGE: case SPVC_BASETYPE_SAMPLED_IMAGE:
return GL_IMAGE_2D; return GL_IMAGE_2D;
case SPVC_BASETYPE_SAMPLER: case SPVC_BASETYPE_SAMPLER:
return GL_SAMPLER_2D; return GL_SAMPLER_2D;
case SPVC_BASETYPE_STRUCT: case SPVC_BASETYPE_STRUCT:
case SPVC_BASETYPE_VOID: case SPVC_BASETYPE_VOID:
case SPVC_BASETYPE_UNKNOWN: case SPVC_BASETYPE_UNKNOWN:
case SPVC_BASETYPE_ACCELERATION_STRUCTURE: case SPVC_BASETYPE_ACCELERATION_STRUCTURE:
default: default:
return GL_FALSE; return GL_FALSE;
} }
} }
} } // namespace MG_Util
} } // namespace MobileGL
MobileGL/MG_Util/Debug/Log.cpp
+6 -5
View File
@@ -20,7 +20,7 @@ namespace MobileGL {
} }
std::string GetThreadName() { std::string GetThreadName() {
char buffer[64] = { 0 }; char buffer[64] = {0};
#if defined(_WIN32) && !defined(__MINGW32__) #if defined(_WIN32) && !defined(__MINGW32__)
PWSTR desc = nullptr; PWSTR desc = nullptr;
if (SUCCEEDED(GetThreadDescription(GetCurrentThread(), &desc))) { if (SUCCEEDED(GetThreadDescription(GetCurrentThread(), &desc))) {
@@ -37,7 +37,7 @@ namespace MobileGL {
using namespace std::chrono; using namespace std::chrono;
auto now = system_clock::now(); auto now = system_clock::now();
std::time_t tt = system_clock::to_time_t(now); std::time_t tt = system_clock::to_time_t(now);
struct tm tm {}; struct tm tm{};
#if defined(_WIN32) #if defined(_WIN32)
localtime_s(&tm, &tt); localtime_s(&tm, &tt);
#else #else
@@ -69,7 +69,8 @@ namespace MobileGL {
void Log(const char* levelTag, android_LogPriority androidLogLevel, const char* fmt, ...) { void Log(const char* levelTag, android_LogPriority androidLogLevel, const char* fmt, ...) {
std::lock_guard<std::mutex> lock(s_mutex); std::lock_guard<std::mutex> lock(s_mutex);
std::string header = "[" + GetCurrentTime() + "] [" + GetOSName() + " " + GetThreadName() + "/" + levelTag + "]: "; std::string header =
"[" + GetCurrentTime() + "] [" + GetOSName() + " " + GetThreadName() + "/" + levelTag + "]: ";
char buffer[1024]; char buffer[1024];
va_list args; va_list args;
@@ -98,5 +99,5 @@ namespace MobileGL {
} }
#endif #endif
} }
} } // namespace MG_Util::Debug
} } // namespace MobileGL
MobileGL/MG_Util/GLExtensions.h
+763 -763
View File
File diff suppressed because it is too large Load Diff
MobileGL/MG_Util/Metrics/BufferMetrics.cpp
+9 -9
View File
@@ -5,9 +5,9 @@
#include "BufferMetrics.h" #include "BufferMetrics.h"
namespace MobileGL { namespace MobileGL {
namespace MG_Util { namespace MG_Util {
SizeT GetGLTypeSize(GLenum type) { SizeT GetGLTypeSize(GLenum type) {
switch (type) { switch (type) {
// Scalars // Scalars
case GL_BYTE: case GL_BYTE:
case GL_UNSIGNED_BYTE: case GL_UNSIGNED_BYTE:
@@ -30,10 +30,10 @@ namespace MG_Util {
case GL_UNSIGNED_INT_5_9_9_9_REV: case GL_UNSIGNED_INT_5_9_9_9_REV:
return 4; return 4;
case GL_DOUBLE: case GL_DOUBLE:
#ifdef GL_ARB_gpu_shader_int64 #ifdef GL_ARB_gpu_shader_int64
case GL_UNSIGNED_INT64_ARB: case GL_UNSIGNED_INT64_ARB:
case GL_INT64_ARB: case GL_INT64_ARB:
#endif #endif
return 8; return 8;
// ---- Vector Types ---- // ---- Vector Types ----
@@ -72,7 +72,7 @@ namespace MG_Util {
return 3 * 3 * sizeof(GLfloat); return 3 * 3 * sizeof(GLfloat);
case GL_FLOAT_MAT4: case GL_FLOAT_MAT4:
return 4 * 4 * sizeof(GLfloat); return 4 * 4 * sizeof(GLfloat);
// Float non-square // Float non-square
case GL_FLOAT_MAT2x3: case GL_FLOAT_MAT2x3:
return 2 * 3 * sizeof(GLfloat); return 2 * 3 * sizeof(GLfloat);
@@ -111,7 +111,7 @@ namespace MG_Util {
default: default:
return -1; return -1;
}
} }
} } // namespace MG_Util
} } // namespace MobileGL
}
MobileGL/MG_Util/Metrics/BufferMetrics.h
+5 -5
View File
@@ -8,9 +8,9 @@
#include <Includes.h> #include <Includes.h>
namespace MobileGL { namespace MobileGL {
namespace MG_Util { namespace MG_Util {
SizeT GetGLTypeSize(GLenum type); SizeT GetGLTypeSize(GLenum type);
} }
} } // namespace MobileGL
#endif //BUFFERMETRICS_H #endif // BUFFERMETRICS_H
MobileGL/MG_Util/ShaderTranspiler/ShaderCompiler.cpp
+5 -2
View File
@@ -139,7 +139,9 @@ namespace MobileGL {
tshader->setEnvInput(glslang::EShSourceGlsl, lang, glslang::EShClientVulkan, 450); tshader->setEnvInput(glslang::EShSourceGlsl, lang, glslang::EShClientVulkan, 450);
tshader->setEnvClient(glslang::EShClientVulkan, glslang::EShTargetVulkan_1_3); tshader->setEnvClient(glslang::EShClientVulkan, glslang::EShTargetVulkan_1_3);
tshader->setEnvTarget(glslang::EShTargetSpv, tshader->setEnvTarget(glslang::EShTargetSpv,
((attrib.flags & ShaderCompileBits::EmitDiscardAsDemote) ? glslang::EShTargetSpv_1_6 : glslang::EShTargetSpv_1_5)); ((attrib.flags & ShaderCompileBits::EmitDiscardAsDemote)
? glslang::EShTargetSpv_1_6
: glslang::EShTargetSpv_1_5));
} }
tshader->setAutoMapLocations(true); tshader->setAutoMapLocations(true);
tshader->setAutoMapBindings(true); tshader->setAutoMapBindings(true);
@@ -192,7 +194,8 @@ namespace MobileGL {
return program; return program;
} }
Result<Vector<Vector<unsigned>>> ShaderCompiler::GetSpirvBinaryFromProgram(const ProgramBinaryAttrib &attrib) { Result<Vector<Vector<unsigned>>> ShaderCompiler::GetSpirvBinaryFromProgram(
const ProgramBinaryAttrib& attrib) {
glslang::SpvOptions spvOptions; glslang::SpvOptions spvOptions;
spvOptions.disableOptimizer = false; spvOptions.disableOptimizer = false;
MobileGL/MG_Util/ShaderTranspiler/SpvcSession.cpp
+2 -1
View File
@@ -93,7 +93,8 @@ namespace MobileGL {
SPVC_CHK_RESULT(spvc_compiler_type_struct_member_offset(compiler, type, j, &memberOffset);) SPVC_CHK_RESULT(spvc_compiler_type_struct_member_offset(compiler, type, j, &memberOffset);)
metadata.plainUniformOffsetsInUBO[memberName] = memberOffset; metadata.plainUniformOffsetsInUBO[memberName] = memberOffset;
SizeT memberSize = 0; SizeT memberSize = 0;
SPVC_CHK_RESULT(spvc_compiler_get_declared_struct_member_size(compiler, type, j, &memberSize);) SPVC_CHK_RESULT(
spvc_compiler_get_declared_struct_member_size(compiler, type, j, &memberSize);)
metadata.plainUniformMemberSizesInBytes[memberName] = memberSize; metadata.plainUniformMemberSizesInBytes[memberName] = memberSize;
auto memberTypeId = spvc_type_get_member_type(type, j); auto memberTypeId = spvc_type_get_member_type(type, j);
MobileGL/MG_Util/ShaderTranspiler/SpvcSession.h
+17 -18
View File
@@ -26,26 +26,25 @@ namespace MobileGL {
static Uint32 getByteSizeOfBaseType(const spvc_basetype type) { static Uint32 getByteSizeOfBaseType(const spvc_basetype type) {
switch (type) { switch (type) {
case SPVC_BASETYPE_INT8: case SPVC_BASETYPE_INT8:
case SPVC_BASETYPE_UINT8: case SPVC_BASETYPE_UINT8:
return 1; return 1;
case SPVC_BASETYPE_INT16: case SPVC_BASETYPE_INT16:
case SPVC_BASETYPE_UINT16: case SPVC_BASETYPE_UINT16:
case SPVC_BASETYPE_FP16: case SPVC_BASETYPE_FP16:
return 2; return 2;
case SPVC_BASETYPE_INT32: case SPVC_BASETYPE_INT32:
case SPVC_BASETYPE_UINT32: case SPVC_BASETYPE_UINT32:
case SPVC_BASETYPE_FP32: case SPVC_BASETYPE_FP32:
return 4; return 4;
case SPVC_BASETYPE_INT64: case SPVC_BASETYPE_INT64:
case SPVC_BASETYPE_UINT64: case SPVC_BASETYPE_UINT64:
case SPVC_BASETYPE_FP64: case SPVC_BASETYPE_FP64:
return 8; return 8;
default: default:
return 0; return 0;
} }
} }
}; };
struct SpvcMetadata { struct SpvcMetadata {
MobileGL/MG_Util/ShaderTranspiler/glslang/UniformTraverser.cpp
+30 -32
View File
@@ -5,36 +5,34 @@
#include "UniformTraverser.h" #include "UniformTraverser.h"
namespace MobileGL { namespace MobileGL {
namespace MG_Util { namespace MG_Util {
namespace ShaderTranspiler { namespace ShaderTranspiler {
void UniformTraverser::visitSymbol(glslang::TIntermSymbol *symbol) { void UniformTraverser::visitSymbol(glslang::TIntermSymbol* symbol) {
auto parent = getParentNode(); auto parent = getParentNode();
if (!parent) if (!parent) return;
return; auto parentAgg = parent->getAsAggregate();
auto parentAgg = parent->getAsAggregate(); if (!parentAgg || parentAgg->getOp() != glslang::EOpLinkerObjects) return;
if (!parentAgg || parentAgg->getOp() != glslang::EOpLinkerObjects)
return;
const auto &type = symbol->getType(); const auto& type = symbol->getType();
if (symbol->getQualifier().isUniform() && type.getBasicType() != glslang::EbtSampler) { if (symbol->getQualifier().isUniform() && type.getBasicType() != glslang::EbtSampler) {
m_collectedSymbols.emplace_back(symbol); m_collectedSymbols.emplace_back(symbol);
// auto& name = symbol->getName(); // auto& name = symbol->getName();
// auto qualifier = symbol->getQualifier(); // auto qualifier = symbol->getQualifier();
// //
// printf("layout(location = %d) uniform %s\n", qualifier.layoutLocation, name.c_str()); // printf("layout(location = %d) uniform %s\n", qualifier.layoutLocation, name.c_str());
// auto &uniform = uniforms.emplace_back(); // auto &uniform = uniforms.emplace_back();
// uniform.name = name; // uniform.name = name;
// uniform.storageQualifier = qualifier.storage; // uniform.storageQualifier = qualifier.storage;
// uniform.layoutLocation = qualifier.layoutLocation; // uniform.layoutLocation = qualifier.layoutLocation;
// uniform.layoutBinding = qualifier.layoutBinding; // uniform.layoutBinding = qualifier.layoutBinding;
// uniform.layoutPacking = qualifier.layoutPacking; // uniform.layoutPacking = qualifier.layoutPacking;
} }
// else if (type.getBasicType() == glslang::EbtSampler) { // else if (type.getBasicType() == glslang::EbtSampler) {
// auto &uniform = samplers.emplace_back(); // auto &uniform = samplers.emplace_back();
// uniform.name = symbol->getName(); // uniform.name = symbol->getName();
// uniform.sampler = type.getSampler(); // uniform.sampler = type.getSampler();
// } // }
} }
} } // namespace ShaderTranspiler
} } // namespace MG_Util
} } // namespace MobileGL
MobileGL/MG_Util/ShaderTranspiler/glslang/UniformTraverser.h
+14 -13
View File
@@ -8,17 +8,18 @@
#include "Includes.h" #include "Includes.h"
namespace MobileGL { namespace MobileGL {
namespace MG_Util { namespace MG_Util {
namespace ShaderTranspiler { namespace ShaderTranspiler {
class UniformTraverser : public glslang::TIntermTraverser { class UniformTraverser : public glslang::TIntermTraverser {
public: public:
void visitSymbol(glslang::TIntermSymbol *symbol) override; void visitSymbol(glslang::TIntermSymbol* symbol) override;
Vector<glslang::TIntermSymbol*>& GetCollectedSymbols() { return m_collectedSymbols; } Vector<glslang::TIntermSymbol*>& GetCollectedSymbols() { return m_collectedSymbols; }
private:
Vector<glslang::TIntermSymbol*> m_collectedSymbols;
};
}
}
}
#endif //MOBILEGL_UNIFORMTRAVERSER_H private:
Vector<glslang::TIntermSymbol*> m_collectedSymbols;
};
} // namespace ShaderTranspiler
} // namespace MG_Util
} // namespace MobileGL
#endif // MOBILEGL_UNIFORMTRAVERSER_H