[Feat|Fix|Improvement] (All): Continue building the basic structure.

Feat: implement MG_Impl/Buffer
Feat: implement MG_State/ErrorState and integrate it into MG_State/GLContext
Feat: add buffer deletion management
Feat: introduce `INSERTION_POINT` (https://github.com/MobileGL-Dev/MobileGLCodeManager)
Feat: add tests about MG_Impl/Buffer and buffer deletion feature
Feat: add several converters
Fix: fix some compiling errors
Fix: fix some incorrect behaviors in MG_State/Buffer
Improvement: remove some current statements at the beginning of the source file, which will be added uniformly soon
Improvement: optimize some naming
This commit is contained in:
BZLZHH
2025-07-23 23:04:36 +08:00
parent 06804d94f8
commit e79a2fa809
37 changed files with 1377 additions and 118 deletions
+249 -3
View File
@@ -291,9 +291,8 @@ TEST_F(BufferTest, PartialUpdate) {
Vector<Int> update{ 999, 888 };
bufObj->UploadSubData(
sizeof(Int),
update.size() * sizeof(Int),
update.data()
{ (void*)(update.data()), (SizeT)(update.size() * sizeof(Int)) },
sizeof(Int)
);
Vector<Int> expected{ 100, 999, 888, 400, 500 };
@@ -307,3 +306,250 @@ TEST_F(BufferTest, PartialUpdate) {
ASSERT_EQ(dirty.start, sizeof(Int));
ASSERT_EQ(dirty.end, 3 * sizeof(Int));
}
TEST_F(BufferTest, DeleteBufferObject) {
auto bufferNames = glContext.GenBufferNames(1);
auto& slot = glContext.GetBufferBindingSlot(BufferTarget::Vertex);
auto bufObj = glContext.CreateBufferObject(bufferNames[0]);
slot.Bind(bufObj);
ASSERT_TRUE(slot.GetBoundObject() == bufObj);
glContext.MarkBufferObjectForDeletion(bufferNames[0]);
ASSERT_TRUE(slot.GetBoundObject() == nullptr);
ASSERT_FALSE(glContext.GetBufferObject(bufferNames[0]));
}
using namespace MobileGL::MG_Impl::GLImpl;
class GeneralBufferTest : public ::testing::Test {
protected:
void SetUp() override {
MG_State::pGLContext = new MG_State::GLState::GLContext();
}
GLuint CreateBoundBuffer(GLenum target, GLsizeiptr size, GLenum usage) {
GLuint buffer;
GenBuffers(1, &buffer);
BindBuffer(target, buffer);
BufferData(target, size, nullptr, usage);
EXPECT_EQ(GetError(), GL_NO_ERROR);
return buffer;
}
};
TEST_F(GeneralBufferTest, General_BufferLifecycle) {
GLuint buffers[3];
GenBuffers(3, buffers);
EXPECT_NE(buffers[0], 0);
EXPECT_NE(buffers[1], 0);
EXPECT_NE(buffers[2], 0);
EXPECT_NE(buffers[0], buffers[1]);
GLuint deleteBuf = buffers[1];
DeleteBuffers(1, &deleteBuf);
BindBuffer(GL_ARRAY_BUFFER, deleteBuf);
EXPECT_EQ(GetError(), GL_INVALID_OPERATION);
EXPECT_EQ(GetError(), GL_NO_ERROR);
}
TEST_F(GeneralBufferTest, General_BufferDataOperations) {
GLuint buffer = CreateBoundBuffer(GL_ARRAY_BUFFER, 100, GL_STATIC_DRAW);
const char initData[100] = { 0 };
char readBack[100];
void* mapped = MapBuffer(GL_ARRAY_BUFFER, GL_READ_ONLY);
ASSERT_NE(mapped, nullptr);
memcpy(readBack, mapped, 100);
EXPECT_EQ(memcmp(initData, readBack, 100), 0);
UnmapBuffer(GL_ARRAY_BUFFER);
const char subData[] = "TEST";
BufferSubData(GL_ARRAY_BUFFER, 10, sizeof(subData), subData);
mapped = MapBuffer(GL_ARRAY_BUFFER, GL_READ_ONLY);
memcpy(readBack, (char*)mapped + 10, sizeof(subData));
EXPECT_STREQ(readBack, "TEST");
UnmapBuffer(GL_ARRAY_BUFFER);
EXPECT_EQ(GetError(), GL_NO_ERROR);
}
TEST_F(GeneralBufferTest, General_BufferCopy) {
GLuint src = CreateBoundBuffer(GL_COPY_READ_BUFFER, 50, GL_STATIC_READ);
GLuint dst = CreateBoundBuffer(GL_COPY_WRITE_BUFFER, 50, GL_STATIC_DRAW);
const char srcData[] = "SOURCE_BUFFER_DATA";
BufferSubData(GL_COPY_READ_BUFFER, 0, sizeof(srcData), srcData);
void* srcMappedData = MapBuffer(GL_COPY_READ_BUFFER, GL_READ_ONLY);
EXPECT_STREQ((char*)srcMappedData, "SOURCE_BUFFER_DATA");
UnmapBuffer(GL_COPY_READ_BUFFER);
CopyBufferSubData(GL_COPY_READ_BUFFER, GL_COPY_WRITE_BUFFER, 0, 10, sizeof(srcData));
char result[50];
void* mapped = MapBuffer(GL_COPY_WRITE_BUFFER, GL_READ_ONLY);
memcpy(result, (char*)mapped + 10, sizeof(srcData));
EXPECT_STREQ(result, "SOURCE_BUFFER_DATA");
UnmapBuffer(GL_COPY_WRITE_BUFFER);
EXPECT_EQ(GetError(), GL_NO_ERROR);
}
TEST_F(GeneralBufferTest, General_BufferMapping) {
GLuint buffer = 0;
GenBuffers(1, &buffer);
BindBuffer(GL_ARRAY_BUFFER, buffer);
Vector<char> data;
data.resize(100, '\0');
BufferData(GL_ARRAY_BUFFER, data.size(), data.data(), GL_DYNAMIC_DRAW);
void* fullMap = MapBuffer(GL_ARRAY_BUFFER, GL_READ_WRITE);
ASSERT_NE(fullMap, nullptr);
strcpy((char*)fullMap, " Full mapping test");
EXPECT_TRUE(UnmapBuffer(GL_ARRAY_BUFFER));
void* partialMap = MapBufferRange(GL_ARRAY_BUFFER, 0, 30,
GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT);
ASSERT_NE(partialMap, nullptr);
strcpy((char*)partialMap, "Partial (not valid value)");
FlushMappedBufferRange(GL_ARRAY_BUFFER, 0, 7);
EXPECT_TRUE(UnmapBuffer(GL_ARRAY_BUFFER));
partialMap = MapBufferRange(GL_ARRAY_BUFFER, 20, 40,
GL_MAP_WRITE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT);
ASSERT_NE(partialMap, nullptr);
strcpy((char*)partialMap, ": modified data (not valid value)");
FlushMappedBufferRange(GL_ARRAY_BUFFER, 0, 15);
EXPECT_TRUE(UnmapBuffer(GL_ARRAY_BUFFER));
char verify[40];
void* verifyMap = MapBuffer(GL_ARRAY_BUFFER, GL_READ_ONLY);
memcpy(verify, (char*)verifyMap, 40);
EXPECT_STREQ(verify, "Partial mapping test: modified data");
UnmapBuffer(GL_ARRAY_BUFFER);
EXPECT_EQ(GetError(), GL_NO_ERROR);
}
TEST_F(GeneralBufferTest, General_InvalidOperations) {
EXPECT_EQ(MapBuffer(GL_ARRAY_BUFFER, GL_READ_ONLY), nullptr); // GL_INVALID_OPERATION
EXPECT_EQ(GetError(), GL_INVALID_OPERATION);
GLuint buffer = CreateBoundBuffer(GL_ARRAY_BUFFER, 50, GL_STREAM_READ);
EXPECT_EQ(MapBuffer(0xFFFFFFFF, GL_READ_ONLY), nullptr); // GL_INVALID_ENUM
void* mapped = MapBuffer(GL_ARRAY_BUFFER, GL_READ_WRITE);
EXPECT_TRUE(UnmapBuffer(GL_ARRAY_BUFFER));
EXPECT_FALSE(UnmapBuffer(GL_ARRAY_BUFFER)); // GL_INVALID_OPERATION
EXPECT_EQ(GetError(), GL_INVALID_ENUM);
EXPECT_EQ(GetError(), GL_INVALID_OPERATION);
EXPECT_EQ(GetError(), GL_NO_ERROR);
}
TEST_F(GeneralBufferTest, General_MapFlags) {
GLuint buffer = CreateBoundBuffer(GL_ARRAY_BUFFER, 100, GL_DYNAMIC_COPY);
void* roMap = MapBufferRange(GL_ARRAY_BUFFER, 0, 100, GL_MAP_READ_BIT);
ASSERT_NE(roMap, nullptr);
EXPECT_TRUE(UnmapBuffer(GL_ARRAY_BUFFER));
void* nosyncMap = MapBufferRange(GL_ARRAY_BUFFER, 0, 100,
GL_MAP_WRITE_BIT | GL_MAP_UNSYNCHRONIZED_BIT);
ASSERT_NE(nosyncMap, nullptr);
memset(nosyncMap, 0xAA, 100);
EXPECT_TRUE(UnmapBuffer(GL_ARRAY_BUFFER));
EXPECT_EQ(GetError(), GL_NO_ERROR);
}
TEST_F(GeneralBufferTest, General_GeneralTest_1) {
GLuint buffers[3];
GenBuffers(3, buffers);
const GLuint vbo = buffers[0];
const GLuint ibo = buffers[1];
const GLuint staging = buffers[2];
BindBuffer(GL_ARRAY_BUFFER, vbo);
BufferData(GL_ARRAY_BUFFER, 64, nullptr, GL_STATIC_DRAW);
const float vertexData[] = { 0.1f, 0.2f, 0.3f, 1.0f };
BufferSubData(GL_ARRAY_BUFFER, 0, sizeof(vertexData), vertexData);
BindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
const uint16_t indexData[] = { 0, 1, 2, 3, 0 };
BufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indexData), indexData, GL_STATIC_DRAW);
const uint16_t newIndices[] = { 4, 5 };
BufferSubData(GL_ELEMENT_ARRAY_BUFFER, 2 * sizeof(uint16_t),
sizeof(newIndices), newIndices);
BindBuffer(GL_COPY_READ_BUFFER, staging);
const char stagingData[] = "StagingBufferData";
BufferData(GL_COPY_READ_BUFFER, sizeof(stagingData), stagingData, GL_STREAM_COPY);
CopyBufferSubData(GL_COPY_READ_BUFFER, GL_ARRAY_BUFFER,
0, 40, sizeof(stagingData));
BindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
void* fullMap = MapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_READ_WRITE);
ASSERT_NE(fullMap, nullptr);
uint16_t* indices = static_cast<uint16_t*>(fullMap);
indices[0] = 10;
EXPECT_TRUE(UnmapBuffer(GL_ELEMENT_ARRAY_BUFFER));
BindBuffer(GL_ARRAY_BUFFER, vbo);
void* partialMap = MapBufferRange(GL_ARRAY_BUFFER, 20, 8,
GL_MAP_WRITE_BIT |
GL_MAP_FLUSH_EXPLICIT_BIT);
ASSERT_NE(partialMap, nullptr);
const char partialWriteData[] = "PARTIAL"; // 7 chars + '\0' = 8 bytes
memcpy(partialMap, partialWriteData, sizeof(partialWriteData));
FlushMappedBufferRange(GL_ARRAY_BUFFER, 0, sizeof(partialWriteData));
EXPECT_TRUE(UnmapBuffer(GL_ARRAY_BUFFER));
BindBuffer(GL_ARRAY_BUFFER, vbo);
void* verifyMap = MapBufferRange(GL_ARRAY_BUFFER, 0, 64, GL_MAP_READ_BIT);
ASSERT_NE(verifyMap, nullptr);
const float* verts = static_cast<const float*>(verifyMap);
EXPECT_FLOAT_EQ(verts[0], 0.1f);
EXPECT_FLOAT_EQ(verts[1], 0.2f);
const char* partialData = static_cast<const char*>(verifyMap) + 20;
EXPECT_STREQ(partialData, "PARTIAL");
const char* copiedData = static_cast<const char*>(verifyMap) + 40;
EXPECT_STREQ(copiedData, "StagingBufferData");
EXPECT_TRUE(UnmapBuffer(GL_ARRAY_BUFFER));
BindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibo);
void* iboMap = MapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_READ_ONLY);
const uint16_t* finalIndices = static_cast<const uint16_t*>(iboMap);
EXPECT_EQ(finalIndices[0], 10);
EXPECT_EQ(finalIndices[2], 4);
EXPECT_TRUE(UnmapBuffer(GL_ELEMENT_ARRAY_BUFFER));
DeleteBuffers(1, &staging);
BindBuffer(GL_COPY_READ_BUFFER, staging);
GLenum err = GetError();
EXPECT_EQ(err, GL_INVALID_OPERATION);
GLuint toDelete[] = { vbo, ibo };
DeleteBuffers(2, toDelete);
EXPECT_EQ(GetError(), GL_NO_ERROR);
}
+13
View File
@@ -6,6 +6,19 @@ add_executable(
${MGL_ROOT}/MobileGL/MG_State/GLState/Core.cpp
${MGL_ROOT}/MobileGL/MG_State/GLState/BufferState/BufferState.cpp
${MGL_ROOT}/MobileGL/MG_State/GLState/ErrorState/Error.cpp
${MGL_ROOT}/MobileGL/MG_Impl/GLImpl/Buffer/GL_Buffer.cpp
${MGL_ROOT}/MobileGL/MG_Impl/GLImpl/Getter/GL_Getter.cpp
${MGL_ROOT}/MobileGL/MG_Impl/GLImpl/Buffer/Validators.cpp
${MGL_ROOT}/MobileGL/MG_Util/Converters/GLToStr/GLEnumConverter.cpp
${MGL_ROOT}/MobileGL/MG_Util/Converters/MGToStr/GLExtensionConverter.cpp
${MGL_ROOT}/MobileGL/MG_Util/Converters/MGToStr/BufferEnumConverter.cpp
${MGL_ROOT}/MobileGL/MG_Util/Converters/GLToGlslang/GLShaderLangConverter.cpp
${MGL_ROOT}/MobileGL/MG_Util/Converters/MGToGL/ErrorCodeConverter.cpp
${MGL_ROOT}/MobileGL/MG_Util/Converters/MGToGL/BufferEnumConverter.cpp
${MGL_ROOT}/MobileGL/MG_Util/Converters/GLToMG/BufferEnumConverter.cpp
${MGL_ROOT}/MobileGL/MG_Backend/Init.cpp
${MGL_ROOT}/MobileGL/MG_Util/Debug/Log.cpp
)
target_include_directories(BufferTest PRIVATE