From 6901e9584f117f5257032ab14762ab64b8335dad Mon Sep 17 00:00:00 2001 From: BZLZHH Date: Fri, 16 May 2025 23:23:16 +0800 Subject: [PATCH] [Feat] (BufferState): Implement MapBufferRange, FlushMappedBufferRange and CopyBufferSubData. --- .../Implementations/GL/Buffer/GL_Buffer.cpp | 63 +++++++-- .../Implementations/GL/Buffer/GL_Buffer.h | 3 + .../GLFuncsDefinitions/GLFuncsDefinitions.cpp | 6 +- MG/MG_GL/State/Buffer/BufferState.cpp | 130 +++++++++++++----- MG/MG_GL/State/Buffer/BufferState.h | 9 +- MG/MG_GL/State/Core/GLState.cpp | 17 ++- MG/MG_GL/State/Core/GLState.h | 4 +- 7 files changed, 176 insertions(+), 56 deletions(-) diff --git a/MG/MG_GL/Implementations/GL/Buffer/GL_Buffer.cpp b/MG/MG_GL/Implementations/GL/Buffer/GL_Buffer.cpp index 1ee4a7ed..b2032f35 100644 --- a/MG/MG_GL/Implementations/GL/Buffer/GL_Buffer.cpp +++ b/MG/MG_GL/Implementations/GL/Buffer/GL_Buffer.cpp @@ -5,34 +5,79 @@ #include "GL_Buffer.h" namespace MG_GL::GL { + void* MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, + GLbitfield access) { + MG_Util::Debug::LogD("glMapBufferRange, target: %s, offset: %lld, length: %lld, access: 0x%X", + MG_Util::Debug::GLEnumToString(target), + static_cast(offset), + static_cast(length), + access); + void* mappedPointer = nullptr; + GLenum result = MG_State::AcquireBufferMemoryRange(target, offset, length, access, &mappedPointer); + + if (result == GL_NO_ERROR) { + MG_Util::Debug::LogD("Mapped pointer: %p", mappedPointer); + return mappedPointer; + } + MG_State::SetError(result); + MG_Util::Debug::LogE("Error mapping buffer range: %s", MG_Util::Debug::GLEnumToString(result)); + return nullptr; + } + + void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length) { + MG_Util::Debug::LogD("glFlushMappedBufferRange, target: %s, offset: %lld, length: %lld", + MG_Util::Debug::GLEnumToString(target), + static_cast(offset), + static_cast(length)); + GLenum result = MG_State::SyncBufferMemory(target, offset, length); + if (result == GL_NO_ERROR) { + return; + } + MG_State::SetError(result); + MG_Util::Debug::LogE("Error flushing mapped buffer range: %s", + MG_Util::Debug::GLEnumToString(result)); + } + + void CopyBufferSubData(GLenum readTarget, GLenum writeTarget, + GLintptr readOffset, GLintptr writeOffset, + GLsizeiptr size) { + MG_Util::Debug::LogD("glCopyBufferSubData, readTarget: %s, writeTarget: %s, " + "readOffset: %lld, writeOffset: %lld, size: %lld", + MG_Util::Debug::GLEnumToString(readTarget), + MG_Util::Debug::GLEnumToString(writeTarget), + static_cast(readOffset), + static_cast(writeOffset), + static_cast(size)); + GLenum result = MG_State::CopyBufferRange(readTarget, writeTarget, readOffset, writeOffset, size); + if (result == GL_NO_ERROR) { + return; + } + MG_State::SetError(result); + MG_Util::Debug::LogE("Error copying buffer subdata: %s", + MG_Util::Debug::GLEnumToString(result)); + } + void* MapBuffer(GLenum target, GLenum access) { MG_Util::Debug::LogD("glMapBuffer(target=0x%x, access=0x%x)", target, access); - void* mappedPtr = nullptr; GLenum err = MG_State::AcquireBufferMemory(target, access, &mappedPtr); - if (err != GL_NO_ERROR) { MG_State::SetError(err); - MG_Util::Debug::LogE("glMapBuffer failed: %s", - MG_Util::Debug::GLEnumToString(err)); + MG_Util::Debug::LogE("glMapBuffer failed: %s", MG_Util::Debug::GLEnumToString(err)); return nullptr; } - MG_Util::Debug::LogD("glMapBuffer returns %p", mappedPtr); return mappedPtr; } GLboolean UnmapBuffer(GLenum target) { MG_Util::Debug::LogD("glUnmapBuffer(target=0x%x)", target); - GLenum err = MG_State::ReleaseBufferMemory(target); if (err != GL_NO_ERROR) { MG_State::SetError(err); - MG_Util::Debug::LogE("glUnmapBuffer failed: %s", - MG_Util::Debug::GLEnumToString(err)); + MG_Util::Debug::LogE("glUnmapBuffer failed: %s", MG_Util::Debug::GLEnumToString(err)); return GL_FALSE; } - MG_Util::Debug::LogD("glUnmapBuffer succeeded"); return GL_TRUE; } diff --git a/MG/MG_GL/Implementations/GL/Buffer/GL_Buffer.h b/MG/MG_GL/Implementations/GL/Buffer/GL_Buffer.h index a23fde71..156f2d3f 100644 --- a/MG/MG_GL/Implementations/GL/Buffer/GL_Buffer.h +++ b/MG/MG_GL/Implementations/GL/Buffer/GL_Buffer.h @@ -8,6 +8,9 @@ #include "../../../../Includes.h" namespace MG_GL::GL { + void* MapBufferRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access); + void FlushMappedBufferRange(GLenum target, GLintptr offset, GLsizeiptr length); + void CopyBufferSubData(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); void* MapBuffer(GLenum target, GLenum access); GLboolean UnmapBuffer(GLenum target); void BindBuffer(GLenum target, GLuint buffer); diff --git a/MG/MG_GL/Implementations/GL/GLFuncsDefinitions/GLFuncsDefinitions.cpp b/MG/MG_GL/Implementations/GL/GLFuncsDefinitions/GLFuncsDefinitions.cpp index 1b7f4acd..156da322 100644 --- a/MG/MG_GL/Implementations/GL/GLFuncsDefinitions/GLFuncsDefinitions.cpp +++ b/MG/MG_GL/Implementations/GL/GLFuncsDefinitions/GLFuncsDefinitions.cpp @@ -201,7 +201,7 @@ DECLARE_GL_FUNCTION_HEAD(void, BlitFramebuffer, GLint srcX0, GLint srcY0, GLint //DECLARE_GL_FUNCTION_STUB_HEAD(void, BlitFramebuffer, GLint srcX0, GLint srcY0, GLint srcX1, GLint srcY1, GLint dstX0, GLint dstY0, GLint dstX1, GLint dstY1, GLbitfield mask, GLenum filter) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, BlitFramebuffer, srcX0,srcY0,srcX1,srcY1,dstX0,dstY0,dstX1,dstY1,mask,filter) DECLARE_GL_FUNCTION_STUB_HEAD(void, RenderbufferStorageMultisample, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, RenderbufferStorageMultisample, target,samples,internalformat,width,height) DECLARE_GL_FUNCTION_STUB_HEAD(void, FramebufferTextureLayer, GLenum target, GLenum attachment, GLuint texture, GLint level, GLint layer) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, FramebufferTextureLayer, target,attachment,texture,level,layer) -DECLARE_GL_FUNCTION_STUB_HEAD(void, FlushMappedBufferRange, GLenum target, GLintptr offset, GLsizeiptr length) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, FlushMappedBufferRange, target,offset,length) +DECLARE_GL_FUNCTION_HEAD(void, FlushMappedBufferRange, GLenum target, GLintptr offset, GLsizeiptr length) DECLARE_GL_FUNCTION_END_NO_RETURN(void, FlushMappedBufferRange, target,offset,length) DECLARE_GL_FUNCTION_HEAD(void, BindVertexArray, GLuint array) DECLARE_GL_FUNCTION_END_NO_RETURN(void, BindVertexArray, array) DECLARE_GL_FUNCTION_STUB_HEAD(void, DeleteVertexArrays, GLsizei n, const GLuint *arrays) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, DeleteVertexArrays, n,arrays) DECLARE_GL_FUNCTION_HEAD(void, GenVertexArrays, GLsizei n, GLuint *arrays) DECLARE_GL_FUNCTION_END_NO_RETURN(void, GenVertexArrays, n,arrays) @@ -234,7 +234,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, ClearBufferiv, GLenum buffer, GLint drawbuff DECLARE_GL_FUNCTION_STUB_HEAD(void, ClearBufferuiv, GLenum buffer, GLint drawbuffer, const GLuint *value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ClearBufferuiv, buffer,drawbuffer,value) DECLARE_GL_FUNCTION_STUB_HEAD(void, ClearBufferfv, GLenum buffer, GLint drawbuffer, const GLfloat *value) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ClearBufferfv, buffer,drawbuffer,value) DECLARE_GL_FUNCTION_STUB_HEAD(void, ClearBufferfi, GLenum buffer, GLint drawbuffer, GLfloat depth, GLint stencil) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ClearBufferfi, buffer,drawbuffer,depth,stencil) -DECLARE_GL_FUNCTION_STUB_HEAD(void, CopyBufferSubData, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, CopyBufferSubData, readTarget,writeTarget,readOffset,writeOffset,size) +DECLARE_GL_FUNCTION_HEAD(void, CopyBufferSubData, GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) DECLARE_GL_FUNCTION_END_NO_RETURN(void, CopyBufferSubData, readTarget,writeTarget,readOffset,writeOffset,size) DECLARE_GL_FUNCTION_STUB_HEAD(void, GetUniformIndices, GLuint program, GLsizei uniformCount, const GLchar *const*uniformNames, GLuint *uniformIndices) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetUniformIndices, program,uniformCount,uniformNames,uniformIndices) DECLARE_GL_FUNCTION_STUB_HEAD(void, GetActiveUniformsiv, GLuint program, GLsizei uniformCount, const GLuint *uniformIndices, GLenum pname, GLint *params) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, GetActiveUniformsiv, program,uniformCount,uniformIndices,pname,params) DECLARE_GL_FUNCTION_STUB_HEAD(GLuint, GetUniformBlockIndex, GLuint program, const GLchar *uniformBlockName) DECLARE_GL_FUNCTION_STUB_END(GLuint, GetUniformBlockIndex, program,uniformBlockName) @@ -389,7 +389,7 @@ DECLARE_GL_FUNCTION_STUB_HEAD(void, GetSamplerParameterIuiv, GLuint sampler, GLe DECLARE_GL_FUNCTION_STUB_HEAD(void, TexBuffer, GLenum target, GLenum internalformat, GLuint buffer) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, TexBuffer, target,internalformat,buffer) DECLARE_GL_FUNCTION_STUB_HEAD(void, TexBufferRange, GLenum target, GLenum internalformat, GLuint buffer, GLintptr offset, GLsizeiptr size) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, TexBufferRange, target,internalformat,buffer,offset,size) DECLARE_GL_FUNCTION_STUB_HEAD(void, TexStorage3DMultisample, GLenum target, GLsizei samples, GLenum internalformat, GLsizei width, GLsizei height, GLsizei depth, GLboolean fixedsamplelocations) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, TexStorage3DMultisample, target,samples,internalformat,width,height,depth,fixedsamplelocations) -DECLARE_GL_FUNCTION_STUB_HEAD(void*, MapBufferRange, GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) DECLARE_GL_FUNCTION_STUB_END(void*, MapBufferRange, target,offset,length,access) +DECLARE_GL_FUNCTION_HEAD(void*, MapBufferRange, GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access) DECLARE_GL_FUNCTION_END(void*, MapBufferRange, target,offset,length,access) DECLARE_GL_FUNCTION_STUB_HEAD(void, ClearIndex, GLfloat c ) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, ClearIndex,c) DECLARE_GL_FUNCTION_STUB_HEAD(void, IndexMask, GLuint mask ) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, IndexMask,mask) DECLARE_GL_FUNCTION_STUB_HEAD(void, AlphaFunc, GLenum func, GLclampf ref ) DECLARE_GL_FUNCTION_STUB_END_NO_RETURN(void, AlphaFunc,func,ref) diff --git a/MG/MG_GL/State/Buffer/BufferState.cpp b/MG/MG_GL/State/Buffer/BufferState.cpp index 111af394..b13a1988 100644 --- a/MG/MG_GL/State/Buffer/BufferState.cpp +++ b/MG/MG_GL/State/Buffer/BufferState.cpp @@ -56,31 +56,10 @@ GLenum BufferState::Create(GLuint buffer) { return GL_NO_ERROR; } -//GLenum BufferState::CreateN(GLsizei n, GLuint* buffers) { -// MG_Util::Debug::LogD("MG_State: Buffer: CreateN called with n=%d", n); -// if (n < 0) return GL_INVALID_VALUE; -// -// for (GLsizei i = 0; i < n; ++i) { -// GLenum result = Create(&buffers[i]); -// if (result != GL_NO_ERROR) { -// MG_Util::Debug::LogE("MG_State: Buffer: CreateN create buffer failed with error 0x%x", result); -// return result; -// } -// } -// MG_Util::Debug::LogD("MG_State: Buffer: CreateN created buffers successfully"); -// return GL_NO_ERROR; -//} - GLenum BufferState::Bind(GLenum target, GLuint buffer) { // We don't handle unallocated buffer names here, just plain bind if (!IsValidTarget_(target)) return GL_INVALID_ENUM; MG_Util::Debug::LogD("MG_State: Buffer: Bind called with target=%s, buffer=%u", MG_Util::Debug::GLEnumToString(target), buffer); - -// if (buffer != 0 && !ValidateAllocatedHandle(buffer)) { -// MG_Util::Debug::LogE("MG_State: Buffer: Binding invalid buffer %d to %s", buffer, MG_Util::Debug::GLEnumToString(target)); -// return GL_INVALID_OPERATION; -// } - currentBindings_[target] = buffer; MG_Util::Debug::LogD("MG_State: Buffer: Bind succeed bind buffer %u to target 0x%x", buffer, target); return GL_NO_ERROR; @@ -106,44 +85,121 @@ GLenum BufferState::CommitStorage(GLenum target, GLsizeiptr size, const void* da return GL_NO_ERROR; } -GLenum BufferState::AcquireBufferMemory(GLenum target, GLenum access, void** mappedPointer) { - if (!IsValidTarget_(target)) return GL_INVALID_ENUM; - if (MG_Constants::Buffer::VALID_ACCESS.find(access) == MG_Constants::Buffer::VALID_ACCESS.end()) { +GLenum BufferState::AcquireBufferMemoryRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, void** mappedPointer) { + MG_Util::Debug::LogD("MG_State: Buffer: AcquireBufferMemoryRange called with target=0x%x, offset=%ld, length=%ld, access=0x%x", target, offset, length, access); + if (!IsValidTarget_(target)) { + MG_Util::Debug::LogE("MG_State: Buffer: AcquireBufferMemoryRange failed: invalid target 0x%x", target); return GL_INVALID_ENUM; - MG_Util::Debug::LogD("MG_State: Buffer: AcquireBufferMemory buffer at target 0x%x acquired mapped memory, access mode = 0x%x", target, access); } - + if (offset < 0 || length <= 0) { + MG_Util::Debug::LogE("MG_State: Buffer: AcquireBufferMemoryRange failed: invalid offset %ld or length %ld", offset, length); + return GL_INVALID_VALUE; + } + auto it = currentBindings_.find(target); - if (it == currentBindings_.end() || it->second == 0) + if (it == currentBindings_.end() || it->second == 0) { + MG_Util::Debug::LogE("MG_State: Buffer: AcquireBufferMemoryRange failed: no buffer bound to target 0x%x", target); return GL_INVALID_OPERATION; + } BufferObject& obj = buffers_[it->second]; - if (obj.isMapped) return GL_INVALID_OPERATION; + MG_Util::Debug::LogD("MG_State: Buffer: AcquireBufferMemoryRange operating on buffer %u", it->second); + if (obj.isMapped) { + MG_Util::Debug::LogE("MG_State: Buffer: AcquireBufferMemoryRange failed: buffer %u is already mapped", it->second); + return GL_INVALID_OPERATION; + } + + const GLbitfield validFlags = GL_MAP_READ_BIT | GL_MAP_WRITE_BIT | GL_MAP_INVALIDATE_RANGE_BIT | GL_MAP_FLUSH_EXPLICIT_BIT | GL_MAP_UNSYNCHRONIZED_BIT | GL_MAP_INVALIDATE_BUFFER_BIT ; + if ((access & ~validFlags) != 0) { + MG_Util::Debug::LogE("MG_State: Buffer: AcquireBufferMemoryRange failed: invalid access flags 0x%x", access); + return GL_INVALID_VALUE; + } + + if (static_cast(offset + length) > obj.data.size()) { + MG_Util::Debug::LogE("MG_State: Buffer: AcquireBufferMemoryRange failed: requested range [%ld, %ld) exceeds buffer size %zu", offset, offset + length, obj.data.size()); + return GL_INVALID_VALUE; + } obj.isMapped = true; - *mappedPointer = obj.data.data(); - obj.accessMode = access; + obj.mapOffset = offset; + obj.mapLength = length; + obj.mapAccessFlags = access; obj.dirty = true; - + *mappedPointer = obj.data.data() + offset; + MG_Util::Debug::LogD("MG_State: Buffer: AcquireBufferMemoryRange succeeded for buffer %u. Mapped pointer: %p", it->second, *mappedPointer); return GL_NO_ERROR; } -GLenum BufferState::ReleaseBufferMemory(GLenum target) { - MG_Util::Debug::LogD("MG_State: Buffer: ReleaseBufferMemory called on target 0x%x",target); +GLenum BufferState::SyncBufferMemory(GLenum target, GLintptr offset, GLsizeiptr length) { if (!IsValidTarget_(target)) return GL_INVALID_ENUM; + if (offset < 0 || length <= 0) return GL_INVALID_VALUE; - auto it = currentBindings_.find(target); if (it == currentBindings_.end() || it->second == 0) return GL_INVALID_OPERATION; BufferObject& obj = buffers_[it->second]; - if (!obj.isMapped) return GL_INVALID_OPERATION; + if (!obj.isMapped || !(obj.mapAccessFlags & GL_MAP_FLUSH_EXPLICIT_BIT)) + return GL_INVALID_OPERATION; + + if (offset < obj.mapOffset || offset + length > obj.mapOffset + obj.mapLength) + return GL_INVALID_VALUE; + + // TODO: Add support for flush range. + // Now only mark it as dirty. + obj.dirty = true; + return GL_NO_ERROR; +} + +GLenum BufferState::CopyBufferRange(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) { + if (!IsValidTarget_(readTarget) || !IsValidTarget_(writeTarget)) + return GL_INVALID_ENUM; + if (readOffset < 0 || writeOffset < 0 || size < 0) + return GL_INVALID_VALUE; + + GLuint readBuffer = currentBindings_[readTarget]; + GLuint writeBuffer = currentBindings_[writeTarget]; + if (readBuffer == 0 || writeBuffer == 0 || readBuffer == writeBuffer) + return GL_INVALID_OPERATION; + + BufferObject& src = buffers_[readBuffer]; + BufferObject& dst = buffers_[writeBuffer]; + + if (static_cast(readOffset + size) > src.data.size() || + static_cast(writeOffset + size) > dst.data.size()) + return GL_INVALID_VALUE; + + memcpy(dst.data.data() + writeOffset, src.data.data() + readOffset, size); + dst.dirty = true; + return GL_NO_ERROR; +} + +GLenum BufferState::AcquireBufferMemory(GLenum target, GLenum access, void** mappedPointer) { + return AcquireBufferMemoryRange(target, 0, buffers_[currentBindings_[target]].data.size(), access, mappedPointer); +} + +GLenum BufferState::ReleaseBufferMemory(GLenum target) { + if (!IsValidTarget_(target)) + return GL_INVALID_ENUM; + + auto it = currentBindings_.find(target); + if (it == currentBindings_.end() || it->second == 0) + return GL_INVALID_OPERATION; + + BufferObject& obj = buffers_[it->second]; + if (!obj.isMapped) + return GL_INVALID_OPERATION; + + if ((obj.mapAccessFlags & GL_MAP_FLUSH_EXPLICIT_BIT) == 0) { + obj.dirty = true; + } obj.isMapped = false; + obj.mapOffset = 0; + obj.mapLength = 0; + obj.mapAccessFlags = 0; obj.accessMode = GL_READ_WRITE; - obj.dirty = true; - MG_Util::Debug::LogD("MG_State: Buffer: ReleaseBufferMemory buffer at target 0x%x released mapped memory", target); + return GL_NO_ERROR; } diff --git a/MG/MG_GL/State/Buffer/BufferState.h b/MG/MG_GL/State/Buffer/BufferState.h index df21623e..f8dbf42b 100644 --- a/MG/MG_GL/State/Buffer/BufferState.h +++ b/MG/MG_GL/State/Buffer/BufferState.h @@ -21,23 +21,28 @@ public: bool isMapped = false; bool generated = false; GLenum accessMode = GL_READ_WRITE; + GLintptr mapOffset = 0; + GLsizeiptr mapLength = 0; + GLbitfield mapAccessFlags = 0; }; // Return: the validity of the operation, according to OpenGL 3 standard GLenum GenName(GLuint* buffer); GLenum GenNameN(GLsizei n, GLuint* buffers); GLenum Create(GLuint buffer); -// GLenum CreateN(GLsizei n, GLuint* buffers); GLenum Bind(GLenum target, GLuint buffer); GLenum CommitStorage(GLenum target, GLsizeiptr size, const void* data, GLenum usage); + GLenum AcquireBufferMemoryRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, void** mappedPointer); + GLenum SyncBufferMemory(GLenum target, GLintptr offset, GLsizeiptr length); + GLenum CopyBufferRange(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); GLenum AcquireBufferMemory(GLenum target, GLenum access, void** mappedPointer); GLenum ReleaseBufferMemory(GLenum target); GLenum QueryPropertyIntVector(GLenum target, GLenum pname, GLint* params) const; + GLenum DeleteN(GLsizei n, const GLuint* buffers); bool ValidateAllocatedHandle(GLuint buffer); bool ValidateGeneratedName(GLuint buffer); void Delete(GLuint buffer); - GLenum DeleteN(GLsizei n, const GLuint* buffers); GLuint GetCurrentBinding(GLenum target) const; unordered_map currentBindings_; diff --git a/MG/MG_GL/State/Core/GLState.cpp b/MG/MG_GL/State/Core/GLState.cpp index ab8fe3fd..123bed8d 100644 --- a/MG/MG_GL/State/Core/GLState.cpp +++ b/MG/MG_GL/State/Core/GLState.cpp @@ -155,6 +155,19 @@ namespace MG_State { GLenum AcquireBufferMemory(GLenum target, GLenum access, void** mappedPtr) { return MG_State_T::bufferState->AcquireBufferMemory(target, access, mappedPtr); } + + GLenum AcquireBufferMemoryRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, void** mappedPointer) { + return MG_State_T::bufferState->AcquireBufferMemoryRange(target, offset, length, access, mappedPointer); + } + + GLenum SyncBufferMemory(GLenum target, GLintptr offset, GLsizeiptr length) { + return MG_State_T::bufferState->SyncBufferMemory(target, offset, length); + } + + GLenum CopyBufferRange(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size) { + return MG_State_T::bufferState->CopyBufferRange(readTarget, writeTarget, readOffset, + writeOffset, size); + } GLenum ReleaseBufferMemory(GLenum target) { return MG_State_T::bufferState->ReleaseBufferMemory(target); @@ -164,10 +177,6 @@ namespace MG_State { return MG_State_T::bufferState->Create(buffer); } -// GLenum CreateBuffers(GLsizei n, GLuint* buffers) { -// return MG_State_T::bufferState->CreateN(n, buffers); -// } - GLenum GenBufferNames(GLsizei n, GLuint* buffers) { return MG_State_T::bufferState->GenNameN(n, buffers); } diff --git a/MG/MG_GL/State/Core/GLState.h b/MG/MG_GL/State/Core/GLState.h index 1845aa6e..7428be78 100644 --- a/MG/MG_GL/State/Core/GLState.h +++ b/MG/MG_GL/State/Core/GLState.h @@ -57,9 +57,11 @@ namespace MG_State { // Buffer GLenum AcquireBufferMemory(GLenum target, GLenum access, void** mappedPtr); + GLenum AcquireBufferMemoryRange(GLenum target, GLintptr offset, GLsizeiptr length, GLbitfield access, void** mappedPointer); + GLenum SyncBufferMemory(GLenum target, GLintptr offset, GLsizeiptr length); + GLenum CopyBufferRange(GLenum readTarget, GLenum writeTarget, GLintptr readOffset, GLintptr writeOffset, GLsizeiptr size); GLenum ReleaseBufferMemory(GLenum target); GLenum CreateBuffer(GLuint buffer); -// GLenum CreateBuffers(GLsizei n, GLuint* buffers); GLenum GenBufferNames(GLsizei n, GLuint* buffers); GLenum BindBuffer(GLenum target, GLuint buffer); GLenum CommitBufferStorage(GLenum target, GLsizeiptr size, const void* data, GLenum usage);