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

MobileGL/MG_State/GLState/BufferState/BufferObject.h

@@ -0,0 +1,88 @@
+#pragma once
+
+namespace MobileGL {
+	enum class BufferTarget {
+		Vertex,
+		Index,
+		Uniform,
+		Array,
+		ElementArray,
+		CopyRead,
+		CopyWrite,
+		PixelPack,
+		PixelUnpack,
+		Query,
+		Texture,
+		TransformFeedback,
+		AtomicCounter,
+		DispatchIndirect,
+		DrawIndirect,
+		ShaderStorage
+	};
+
+	enum class BufferUsage {
+		StreamDraw,
+		StreamRead,
+		StreamCopy,
+		StaticDraw,
+		StaticRead,
+		StaticCopy,
+		DynamicDraw,
+		DynamicRead,
+		DynamicCopy
+	};
+
+	enum class BufferMappingAccessBit : Uint {
+		Read = 0x01,
+		Write = 0x02,
+		InvalidateRange = 0x04,
+		InvalidateBuffer = 0x08,
+		FlushExplicit = 0x10,
+		Unsynchronized = 0x20
+	};
+
+	inline BufferMappingAccessBit operator|(BufferMappingAccessBit a, BufferMappingAccessBit b) {
+		using T = std::underlying_type_t<BufferMappingAccessBit>;
+		return static_cast<BufferMappingAccessBit>(static_cast<T>(a) | static_cast<T>(b));
+	}
+
+	inline BufferMappingAccessBit& operator|=(BufferMappingAccessBit& a, BufferMappingAccessBit b) {
+		a = a | b;
+		return a;
+	}
+
+	inline BufferMappingAccessBit operator&(BufferMappingAccessBit a, BufferMappingAccessBit b) {
+		using T = std::underlying_type_t<BufferMappingAccessBit>;
+		return static_cast<BufferMappingAccessBit>(static_cast<T>(a) & static_cast<T>(b));
+	}
+
+	inline bool any(BufferMappingAccessBit a) {
+		using T = std::underlying_type_t<BufferMappingAccessBit>;
+		return static_cast<T>(a) != 0;
+	}
+
+	namespace MG_State {
+		namespace GLState {
+			class BufferObject {
+			public:
+				void UploadData(DataPtr data);
+				void SetUsage(BufferUsage usage);
+				SizeT GetSize() const;
+				BufferUsage GetUsage() const;
+				Range1D GetDirtyRange() const;
+				SharedPtr<Data> AquireMemory(Bool markMapped);
+				SharedPtr<Data> AquireMemoryRange(Range1D range, BufferMappingAccessBit access);
+				Bool IsMapped() const;
+
+			private:
+				Int m_id = 0;
+				SizeT m_size = 0;
+				BufferUsage m_usage = BufferUsage::StaticDraw;
+				Data m_data;
+				Bool m_isMapped;
+				BufferMappingAccessBit m_mappingAccess;
+				UniquePtr<Range1D> m_dirtyRange;
+			};
+		}
+	}
+}

MobileGL/MG_State/GLState/BufferState/BufferState.cpp

@@ -0,0 +1,48 @@
+#include "../../../Includes.h"
+
+namespace MobileGL {
+	namespace MG_State {
+		namespace GLState {
+			void BufferObject::UploadData(DataPtr data) {
+				m_size = data.size;
+				memcpy(m_data.data(), data.data, data.size);
+				m_dirtyRange = MakeUnique<Range1D>(0, m_size);
+				m_dirtyRange->Extend(0, m_size);
+			}
+
+			SharedPtr<Data> BufferObject::AquireMemory(Bool markMapped = true) {
+				if (markMapped) {
+					m_isMapped = true;
+					m_mappingAccess = BufferMappingAccessBit::Read | BufferMappingAccessBit::Write;
+				}
+				return MakeShared<Data>(m_data);
+			}
+
+			SharedPtr<Data> BufferObject::AquireMemoryRange(Range1D range, BufferMappingAccessBit access) {
+				m_isMapped = true;
+				m_mappingAccess = access;
+				return MakeShared<Data>(m_data);
+			}
+
+			void BufferObject::SetUsage(BufferUsage usage) {
+				m_usage = usage;
+			}
+
+			SizeT BufferObject::GetSize() const {
+				return m_size;
+			}
+
+			BufferUsage BufferObject::GetUsage() const {
+				return m_usage;
+			}
+
+			Range1D BufferObject::GetDirtyRange() const {
+				return *m_dirtyRange;
+			}
+
+			Bool BufferObject::IsMapped() const {
+				return m_isMapped;
+			}
+		}
+	}
+}

MobileGL/MG_State/GLState/BufferState/BufferState.h

@@ -0,0 +1,34 @@
+#pragma once
+
+namespace MobileGL {
+	namespace MG_State {
+		namespace GLState {
+			class BufferState {
+			public:
+				SharedPtr<BufferObject> GetBufferObjectByIndex(Uint index) {
+					auto it = m_bufferObjects.find(index);
+					if (it != m_bufferObjects.end()) {
+						return it->second;
+					}
+					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;
+			};
+		}
+	}
+}

MobileGL/MG_State/GLState/Core.cpp

@@ -0,0 +1 @@
+#include "../../Includes.h"

MobileGL/MG_State/GLState/Core.h

@@ -0,0 +1,23 @@
+#pragma once
+
+namespace MobileGL {
+	namespace MG_State {
+		namespace GLState {
+			class GLContext {
+			public:
+				GLContext() = default;
+
+				// Buffer
+				Vector<Uint> GenBuffersByNum(Uint number);
+				SharedPtr<BufferObject> GetBufferObjByIndex(Uint index);
+				SharedPtr<BufferObject> GetBufferObjByTarget(BufferTarget target);
+				SharedPtr<BufferObject> CreateBufferObject(Uint index);
+				void BindBufferTarget(BufferTarget target, SharedPtr<BufferObject> bufferObject);
+
+			private:
+				// Buffer
+				BufferState bufferState_;
+			};
+		}
+	}
+}