[Feat] (MG_State/GLState): Implement BufferState.

MobileGL/MG_State/GLState/BufferState/BufferObject.h

@@ -33,6 +33,7 @@ namespace MobileGL {
 	};
 
 	enum class BufferMappingAccessBit : Uint {
+		Null = 0x00,
 		Read = 0x01,
 		Write = 0x02,
 		InvalidateRange = 0x04,
@@ -65,13 +66,15 @@ namespace MobileGL {
 		namespace GLState {
 			class BufferObject {
 			public:
+				using TargetEnum = BufferTarget;
+
 				void UploadData(DataPtr data);
 				void SetUsage(BufferUsage usage);
 				SizeT GetSize() const;
 				BufferUsage GetUsage() const;
 				Range1D GetDirtyRange() const;
-				SharedPtr<Data> AquireMemory(Bool markMapped);
+				void* AquireMemory(Bool markMapped, Bool read, Bool write);
-				SharedPtr<Data> AquireMemoryRange(Range1D range, BufferMappingAccessBit access);
+				void* AquireMemoryRange(Range1D range, BufferMappingAccessBit access);
 				Bool IsMapped() const;
 
 			private:

MobileGL/MG_State/GLState/BufferState/BufferState.cpp

@@ -3,6 +3,7 @@
 namespace MobileGL {
 	namespace MG_State {
 		namespace GLState {
+			// BufferObject
 			void BufferObject::UploadData(DataPtr data) {
 				m_size = data.size;
 				memcpy(m_data.data(), data.data, data.size);
@@ -10,18 +11,19 @@ namespace MobileGL {
 				m_dirtyRange->Extend(0, m_size);
 			}
 
-			SharedPtr<Data> BufferObject::AquireMemory(Bool markMapped = true) {
+			void* BufferObject::AquireMemory(Bool markMapped = true, Bool read, Bool write) {
 				if (markMapped) {
 					m_isMapped = true;
-					m_mappingAccess = BufferMappingAccessBit::Read | BufferMappingAccessBit::Write;
+					m_mappingAccess = (read ? BufferMappingAccessBit::Read : BufferMappingAccessBit::Null) |
+						(write ? BufferMappingAccessBit::Write : BufferMappingAccessBit::Null);
 				}
-				return MakeShared<Data>(m_data);
+				return m_data.data();
 			}
 
-			SharedPtr<Data> BufferObject::AquireMemoryRange(Range1D range, BufferMappingAccessBit access) {
+			void* BufferObject::AquireMemoryRange(Range1D range, BufferMappingAccessBit access) {
 				m_isMapped = true;
 				m_mappingAccess = access;
-				return MakeShared<Data>(m_data);
+				return m_data.data() + range.start;
 			}
 
 			void BufferObject::SetUsage(BufferUsage usage) {
@@ -43,6 +45,37 @@ namespace MobileGL {
 			Bool BufferObject::IsMapped() const {
 				return m_isMapped;
 			}
+
+			// BufferState
+			SharedPtr<BufferObject> BufferState::GetBufferObject(Uint index) {
+				auto it = m_bufferObjects.find(index);
+				if (it != m_bufferObjects.end()) {
+					return it->second;
+				}
+				return nullptr;
+			}
+
+			Vector<Uint> BufferState::GenerateNames(Uint number) {
+				Vector<Uint> buffers(number);
+				m_indexGenerator.Generate(number, buffers.data());
+				return buffers;
+			}
+
+			SharedPtr<BufferObject> BufferState::CreateBufferObject(Uint index) {
+				auto bufferObject = MakeShared<BufferObject>();
+				m_bufferObjects[index] = bufferObject;
+				return bufferObject;
+			}
+
+			BindingSlot<BufferObject>& BufferState::GetBindingSlot(BufferTarget target) {
+				for (auto& slot : m_bindingSlots) {
+					if (slot.GetTarget() == target) {
+						return slot;
+					}
+				}
+				m_bindingSlots.emplace_back(target);
+				return m_bindingSlots.back();
+			}
 		}
 	}
 }

MobileGL/MG_State/GLState/BufferState/BufferState.h

@@ -5,29 +5,15 @@ namespace MobileGL {
 		namespace GLState {
 			class BufferState {
 			public:
-				SharedPtr<BufferObject> GetBufferObjectByIndex(Uint index) {
+				SharedPtr<BufferObject> GetBufferObject(Uint index);
-					auto it = m_bufferObjects.find(index);
+				Vector<Uint> GenerateNames(Uint number);
-					if (it != m_bufferObjects.end()) {
+				SharedPtr<BufferObject> CreateBufferObject(Uint index);
-						return it->second;
+				BindingSlot<BufferObject>& GetBindingSlot(BufferTarget target);
-					}
-					return nullptr;
-				}
-
-				Vector<Uint> GenerateByNum(Uint number) {
-					Vector<Uint> buffers;
-					m_indexGenerator.Generate(number, reinterpret_cast<Uint*>(&buffers));
-					return buffers;
-				}
-
-				SharedPtr<BufferObject> CreateBufferObject(Uint index) {
-					auto bufferObject = MakeShared<BufferObject>();
-					m_bufferObjects[index] = bufferObject;
-					return bufferObject;
-				}
 
 			private:
 				UnorderedMap<Uint, SharedPtr<BufferObject>> m_bufferObjects;
 				IndexGenerator<Uint> m_indexGenerator;
+				Vector<BindingSlot<BufferObject>> m_bindingSlots;
 			};
 		}
 	}

MobileGL/MG_State/GLState/Core.cpp

@@ -1 +1,26 @@
 #include "../../Includes.h"
+
+namespace MobileGL {
+    namespace MG_State {
+        namespace GLState {
+            Vector<Uint> GLContext::GenBufferNames(Uint number) {
+                return bufferState_.GenerateNames(number);
+            }
+
+            SharedPtr<BufferObject> GLContext::GetBufferObject(Uint index) {
+                return bufferState_.GetBufferObject(index);
+            }
+
+            BindingSlot<BufferObject>& GLContext::GetBufferBindingSort(BufferTarget target) {
+                return bufferState_.GetBindingSlot(target);
+            }
+
+            SharedPtr<BufferObject> GLContext::CreateBufferObject(Uint index) {
+                return bufferState_.CreateBufferObject(index);
+            }
+
+        }
+
+        GLState::GLContext* pGLContext;
+    }
+}

MobileGL/MG_State/GLState/Core.h

@@ -8,16 +8,17 @@ namespace MobileGL {
 				GLContext() = default;
 
 				// Buffer
-				Vector<Uint> GenBuffersByNum(Uint number);
+				Vector<Uint> GenBufferNames(Uint number);
-				SharedPtr<BufferObject> GetBufferObjByIndex(Uint index);
+				SharedPtr<BufferObject> GetBufferObject(Uint index);
-				SharedPtr<BufferObject> GetBufferObjByTarget(BufferTarget target);
+				BindingSlot<BufferObject>& GetBufferBindingSort(BufferTarget target);
 				SharedPtr<BufferObject> CreateBufferObject(Uint index);	
-				void BindBufferTarget(BufferTarget target, SharedPtr<BufferObject> bufferObject);
 
 			private:
 				// Buffer
 				BufferState bufferState_;
 			};
 		}
+
+		extern GLState::GLContext* pGLContext;
 	}
 }

MobileGL/MG_Util/Types.h

@@ -93,6 +93,32 @@ namespace MobileGL {
 		}
 	};
 
+	template<typename ObjectType>
+	class BindingSlot {
+	public:
+		using TargetEnum = ObjectType::TargetEnum;
+
+		explicit BindingSlot(TargetEnum target)
+			: m_target(target), m_boundObject(nullptr) {
+		}
+
+		void Bind(SharedPtr<ObjectType> object) {
+			m_boundObject = object;
+		}
+
+		SharedPtr<ObjectType> GetBoundObject() const {
+			return m_boundObject;
+		}
+
+		TargetEnum GetTarget() const {
+			return m_target;
+		}
+
+	private:
+		TargetEnum m_target;
+		SharedPtr<ObjectType> m_boundObject;
+	};
+
 	struct Version {
 		Int Major;
 		Int Minor;