devbox
花生_TL007
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

跟着cherno手搓游戏引擎【29】Batch简单合批

作者：花生_TL007 | 2024-03-30 20:26:56

赞

踩

跟着cherno手搓游戏引擎【29】Batch简单合批

思路：

CPU和GPU都开辟同样大小的一大块内存（为了存储顶点信息）

索引在程序运行时生成对应规则后绑定到索引缓冲中

动态生成顶点信息（现在改成Drawquad只是确定图形顶点的位置）

然后在Endscene，将CPU的动态生成的顶点数据上传给GPU，然后再绘制出来

所以，就是根据所绘制的物体，动态生成索引缓冲区，然后根据索引缓冲区一次性绘制多个物体。

实现：

Renderer2D.h:

  1. #pragma once
  2. #include "OrthographicCamera.h"
  3. #include"Texture.h"
  4. namespace YOTO {
  5. 	class Renderer2D
  6. 	{
  7. 	public:
  8. 		//为什么渲染器是静态的：
  9. 		static void Init();
  10. 		static void ShutDown();
  11. 		static void BeginScene(const OrthographicCamera& camera);
  12. 		static void EndScene();
  13. 		static void Flush();
  14.  
  15. 		static void DrawQuad(const glm::vec2& position, const glm::vec2& size ,const glm::vec4& color);
  16. 		static void DrawQuad(const glm::vec3& position, const glm::vec2& size ,const glm::vec4& color);
  17. 		static void DrawQuad(const glm::vec2& position, const glm::vec2& size ,const Ref<Texture2D> texture,float tilingFactor=1.0f,const glm::vec4& tintColor=glm::vec4(1.0f));
  18. 		static void DrawQuad(const glm::vec3& position, const glm::vec2& size ,const Ref<Texture2D> texture,float tilingFactor=1.0f,const glm::vec4& tintColor=glm::vec4(1.0f));
  19.  
  20. 		static void DrawRotatedQuad(const glm::vec2& position, const glm::vec2& size, float rotation,const glm::vec4& color);
  21. 		static void DrawRotatedQuad(const glm::vec3& position, const glm::vec2& size, float rotation,const glm::vec4& color);
  22. 		static void DrawRotatedQuad(const glm::vec2& position, const glm::vec2& size, float rotation,const Ref<Texture2D> texture, float tilingFactor = 1.0f,  const glm::vec4& tintColor = glm::vec4(1.0f));
  23. 		static void DrawRotatedQuad(const glm::vec3& position, const glm::vec2& size, float rotation,const Ref<Texture2D> texture, float tilingFactor = 1.0f, const glm::vec4& tintColor = glm::vec4(1.0f));
  24. 	};
  25. }
  26.  
  27.

Renderer2D.cpp:

  1. #include "ytpch.h"
  2. #include "Renderer2D.h"
  3. #include"VertexArray.h"
  4. #include"Shader.h"
  5. //#include "Platform/OpenGL/OpenGLShader.h"
  6. #include <glm/gtc/matrix_transform.hpp>
  7. #include "RenderCommand.h"
  8. namespace YOTO {
  9. 	/// <summary>
  10. 	/// 为什么QuadVertex的指针可以作为void*data传入glBufferSubData：
  11. 	/// SetLayout配置的就是这三个的顺序，因为glm内部用float实现
  12. 	/// 相当于前三个float是Position，之后四个float组成的Color，
  13. 	/// 最后是两个float组成的TexCoord
  14. 	/// </summary>
  15. 	struct QuadVertex {
  16. 		glm::vec3 Position;
  17. 		glm::vec4 Color;
  18. 		glm::vec2 TexCoord;
  19. 		//，纹理Id，
  20. 	};
  21. 	struct  Renderer2DData {
  22. 		const uint32_t MaxQuads = 10000;
  23. 		const uint32_t MaxVertices = MaxQuads * 4;
  24. 		const uint32_t MaxIndices = MaxQuads * 6;
  25.  
  26. 		//顶点数组
  27. 		Ref<VertexArray> QuadVertexArray;
  28. 		//定带你缓冲
  29. 		Ref<VertexBuffer> QuadVertexBuffer;
  30. 		//Ref<Shader> FlatColorShader;
  31. 		//Shader
  32. 		Ref<Shader> TextureShader;
  33. 		//纹理
  34. 		Ref<Texture2D> WhiteTexture;
  35. 		//记录索引
  36. 		uint32_t QuadIndexCount =0;
  37.  
  38. 		QuadVertex* QuadVertexBufferBase=nullptr;
  39. 		QuadVertex* QuadVertexBufferPtr= nullptr;
  40. 	};
  41. 	//CPU开辟的大内存
  42. 	static Renderer2DData s_Data;
  43.  
  44.  
  45. 	void Renderer2D::Init()
  46. 	{
  47. 		YT_PROFILE_FUNCTION();
  48. 		//---------------------顶点数组--------------------------
  49. 		//创建顶点数组
  50. 		s_Data.QuadVertexArray = VertexArray::Create();
  51. 		// 创建顶点缓冲区,先在GPU开辟一块s_Data.MaxVertices * sizeof(QuadVertex)大小的内存
  52. 		// 与cpu对应大，是为了传输顶点数据
  53. 		//---------------------顶点缓冲区--------------------------
  54. 		s_Data.QuadVertexBuffer =VertexBuffer::Create(s_Data.MaxVertices*sizeof(QuadVertex));
  55. 		s_Data.QuadVertexBuffer->SetLayout({
  56. 				{ShaderDataType::Float3,"a_Position"},
  57. 				{ShaderDataType::Float4,"a_Color"},
  58. 				{ShaderDataType::Float2,"a_TexCoord"}
  59. 			});
  60. 		//顶点数组添加顶点缓冲区，并且在这个缓冲区中设置布局
  61. 		s_Data.QuadVertexArray->AddVertexBuffer(s_Data.QuadVertexBuffer);
  62.  
  63.  
  64. 		// 在CPU开辟存储s_Data.MaxVertices个的QuadVertex的内存
  65. 		s_Data.QuadVertexBufferBase = new QuadVertex[s_Data.MaxVertices];
  66. 		
  67. 		//---------------------索引缓冲区--------------------------
  68. 		//开辟一块索引缓冲区
  69. 		uint32_t* quadIndices = new uint32_t[s_Data.MaxIndices];
  70. 		uint32_t offset = 0;	//配置索引
  71. 		for (uint32_t i = 0; i < s_Data.MaxIndices; i += 6) {
  72. 			quadIndices[i + 0] = offset + 0;
  73. 			quadIndices[i + 1] = offset + 1;
  74. 			quadIndices[i + 2] = offset + 2;
  75.  
  76. 			quadIndices[i + 3] = offset + 2;
  77. 			quadIndices[i + 4] = offset + 3;
  78. 			quadIndices[i + 5] = offset + 0;
  79. 			offset += 4;
  80. 		}
  81.  
  82. 		//创建索引缓冲区
  83. 		Ref<IndexBuffer> quardIB;
  84. 		quardIB =IndexBuffer::Create(quadIndices, s_Data.MaxIndices);
  85. 		s_Data.QuadVertexArray->AddIndexBuffer(quardIB);
  86. 		delete[] quadIndices;	// cpu上传到gpu上了可以删除cpu的索引数据块了
  87.  
  88. 		//---------------------纹理--------------------------
  89. 		// 创建一个白色Texture
  90. 		s_Data.WhiteTexture = Texture2D::Create(1, 1);
  91. 		uint32_t whiteTextureData = 0xffffffff;
  92. 		s_Data.WhiteTexture->SetData(&whiteTextureData, sizeof(uint32_t));
  93.  
  94. 		//---------------------着色器--------------------------
  95. 		//加载shader，并传入shader参数
  96. 		s_Data.TextureShader= Shader::Create("assets/shaders/Texture.glsl");
  97. 		s_Data.TextureShader->Bind();
  98. 		s_Data.TextureShader->SetInt("u_Texture", 0);
  99.  
  100.  
  101.  
  102. 	}
  103. 	void Renderer2D::ShutDown()
  104. 	{
  105. 		YT_PROFILE_FUNCTION();
  106. 		//delete s_Data;
  107. 	}
  108. 	void Renderer2D::BeginScene(const OrthographicCamera& camera)
  109. 	{
  110.  
  111. 		YT_PROFILE_FUNCTION();
  112. 		s_Data.TextureShader->Bind();
  113. 		s_Data.TextureShader->SetMat4("u_ViewProjection", camera.GetViewProjectionMatrix());
  114. 		// 相当于初始化此帧要绘制的索引数量，上传的顶点数据
  115. 		s_Data.QuadIndexCount = 0;
  116. 		//指针指向首部
  117. 		s_Data.QuadVertexBufferPtr = s_Data.QuadVertexBufferBase;
  118. 	}
  119. 	void Renderer2D::EndScene()
  120. 	{
  121. 		YT_PROFILE_FUNCTION();
  122. 		// 计算当前绘制需要多少个顶点数据,注意这里是8！！！！！！
  123. 		uint32_t dataSize = (uint8_t*)s_Data.QuadVertexBufferPtr - (uint8_t*)s_Data.QuadVertexBufferBase;
  124. 		// 截取部分CPU的顶点数据上传OpenGL，
  125. 		s_Data.QuadVertexBuffer->SetData(s_Data.QuadVertexBufferBase, dataSize);
  126. 		Flush();
  127. 	}
  128. 	void Renderer2D::Flush()
  129. 	{
  130. 		RenderCommand::DrawIndexed(s_Data.QuadVertexArray, s_Data.QuadIndexCount);
  131. 	}
  132. 	void Renderer2D::DrawQuad(const glm::vec2& position, const glm::vec2& size, const glm::vec4& color)
  133. 	{
  134. 		DrawQuad({ position.x,position.y,0.0f }, size, color);
  135. 	}
  136. 	void Renderer2D::DrawQuad(const glm::vec3& position, const glm::vec2& size, const glm::vec4& color)
  137. 	{
  138. 		YT_PROFILE_FUNCTION();
  139. 		//s_Data.FlatColorShader->Bind();
  140. 		//s_Data.FlatColorShader->SetFloat4("u_Color", color);
  141. 		//s_Data.TextureShader->Bind();
  142.  
  143. 		s_Data.QuadVertexBufferPtr->Position = position;
  144. 		s_Data.QuadVertexBufferPtr->Color = color;
  145. 		s_Data.QuadVertexBufferPtr->TexCoord = {0.0f,0.0f};
  146. 		s_Data.QuadVertexBufferPtr++;
  147.  
  148. 		s_Data.QuadVertexBufferPtr->Position = { position.x+size.x,position.y,0.0f};
  149. 		s_Data.QuadVertexBufferPtr->Color = color;
  150. 		s_Data.QuadVertexBufferPtr->TexCoord = { 1.0f,0.0f };
  151. 		s_Data.QuadVertexBufferPtr++;
  152.  
  153. 		s_Data.QuadVertexBufferPtr->Position = { position.x + size.x,position.y + size.y,0.0f };
  154. 		s_Data.QuadVertexBufferPtr->Color = color;
  155. 		s_Data.QuadVertexBufferPtr->TexCoord = { 1.0f,1.0f };
  156. 		s_Data.QuadVertexBufferPtr++;
  157.  
  158. 		s_Data.QuadVertexBufferPtr->Position = { position.x,position.y+size.y,0.0f };
  159. 		s_Data.QuadVertexBufferPtr->Color = color;
  160. 		s_Data.QuadVertexBufferPtr->TexCoord = { 0.0f,1.0f };
  161. 		s_Data.QuadVertexBufferPtr++;
  162.  
  163.  
  164. 		s_Data.QuadIndexCount += 6;
  165. 		/*s_Data.TextureShader->SetFloat4("u_Color", color);
  166. 		s_Data.TextureShader->SetFloat("m_TilingFactor", 1.0f);
  167. 		s_Data.WhiteTexture->Bind();*/
  168.  
  169. 		//glm::mat4 transform = glm::translate(glm::mat4(1.0f), position) /**rotation*/ * glm::scale(glm::mat4(1.0f), {size.x,size.y,1.0f});
  170. 		//s_Data.TextureShader->SetMat4("u_Transform", transform);
  171. 		//s_Data.QuadVertexArray->Bind();
  172. 		//RenderCommand::DrawIndexed(s_Data.QuadVertexArray);
  173. 	}
  174. 	void Renderer2D::DrawQuad(const glm::vec2& position, const glm::vec2& size, const Ref<Texture2D> texture,  float tilingFactor, const glm::vec4& tintColor)
  175. 	{
  176. 		DrawQuad({ position.x,position.y,0.0f }, size, texture, tilingFactor, tintColor);
  177. 	}
  178. 	void Renderer2D::DrawQuad(const glm::vec3& position, const glm::vec2& size, const Ref<Texture2D> texture, float tilingFactor, const glm::vec4& tintColor)
  179. 	{
  180. 		YT_PROFILE_FUNCTION();
  181. 		//s_Data.TextureShader->Bind();
  182. 		s_Data.TextureShader->SetFloat4("u_Color", tintColor);
  183. 		s_Data.TextureShader->SetFloat("m_TilingFactor",tilingFactor);
  184. 		texture->Bind();
  185.  
  186.  
  187. 		glm::mat4 transform = glm::translate(glm::mat4(1.0f), position) /**rotation*/ * glm::scale(glm::mat4(1.0f), { size.x,size.y,1.0f });
  188. 		s_Data.TextureShader->SetMat4("u_Transform", transform);
  189.  
  190. 		s_Data.QuadVertexArray->Bind();
  191. 		RenderCommand::DrawIndexed(s_Data.QuadVertexArray);
  192. 		
  193. 	}
  194. 	void Renderer2D::DrawRotatedQuad(const glm::vec2& position, const glm::vec2& size, float rotation, const glm::vec4& color)
  195. 	{
  196. 		DrawRotatedQuad({ position.x,position.y,0.0f }, size, rotation,color);
  197. 	}
  198. 	void Renderer2D::DrawRotatedQuad(const glm::vec3& position, const glm::vec2& size, float rotation, const glm::vec4& color)
  199. 	{
  200. 		YT_PROFILE_FUNCTION();
  201.  
  202. 		s_Data.TextureShader->SetFloat4("u_Color", color);
  203. 		s_Data.TextureShader->SetFloat("m_TilingFactor", 1.0f);
  204. 		s_Data.WhiteTexture->Bind();
  205.  
  206. 		glm::mat4 transform = glm::translate(glm::mat4(1.0f), position) * glm::rotate(glm::mat4(1.0f), rotation, {0.0f,0.0f,1.0f}) * glm::scale(glm::mat4(1.0f), { size.x,size.y,1.0f });
  207. 		s_Data.TextureShader->SetMat4("u_Transform", transform);
  208. 		s_Data.QuadVertexArray->Bind();
  209. 		RenderCommand::DrawIndexed(s_Data.QuadVertexArray);
  210.  
  211. 	}
  212. 	void Renderer2D::DrawRotatedQuad(const glm::vec2& position, const glm::vec2& size, float rotation, const Ref<Texture2D> texture, float tilingFactor, const glm::vec4& tintColor)
  213. 	{
  214. 		DrawRotatedQuad({ position.x,position.y,0.0f }, size, rotation, texture, tilingFactor, tintColor);
  215. 	}
  216. 	void Renderer2D::DrawRotatedQuad(const glm::vec3& position, const glm::vec2& size, float rotation, const Ref<Texture2D> texture, float tilingFactor, const glm::vec4& tintColor)
  217. 	{
  218. 		YT_PROFILE_FUNCTION();
  219. 		//s_Data.TextureShader->Bind();
  220. 		s_Data.TextureShader->SetFloat4("u_Color", tintColor);
  221. 		s_Data.TextureShader->SetFloat("m_TilingFactor", tilingFactor);
  222. 		texture->Bind();
  223.  
  224.  
  225. 		glm::mat4 transform = glm::translate(glm::mat4(1.0f), position) * glm::rotate(glm::mat4(1.0f), rotation, { 0.0f,0.0f,1.0f }) * glm::scale(glm::mat4(1.0f), { size.x,size.y,1.0f });
  226. 		s_Data.TextureShader->SetMat4("u_Transform", transform);
  227.  
  228. 		s_Data.QuadVertexArray->Bind();
  229. 		RenderCommand::DrawIndexed(s_Data.QuadVertexArray);
  230. 	}
  231. }

Buffer.h:添加SetData和Create方法：

  1. #pragma once
  2. namespace YOTO {
  3. 	enum class ShaderDataType{
  4. 	None=0,
  5. 	Float,Float2,Float3,Float4,
  6. 	Mat3,Mat4,
  7. 	Int,Int2,Int3,Int4,
  8. 	Bool,
  9. 	};
  10. 	static uint32_t  ShaderDataTypeSize(ShaderDataType type) {
  11. 		switch (type)
  12. 		{
  13. 		case YOTO::ShaderDataType::Float:
  14. 			return 4;
  15. 			break;
  16. 		case YOTO::ShaderDataType::Float2:
  17. 			return 4*2;
  18. 			break;
  19. 		case YOTO::ShaderDataType::Float3:
  20. 			return 4*3;
  21. 			break;
  22. 		case YOTO::ShaderDataType::Float4:
  23. 			return 4*4;
  24. 			break;
  25. 		case YOTO::ShaderDataType::Mat3:
  26. 			return 4*3*3;
  27. 			break;
  28. 		case YOTO::ShaderDataType::Mat4:
  29. 			return 4*4*4;
  30. 			break;
  31. 		case YOTO::ShaderDataType::Int:
  32. 			return 4;
  33. 			break;
  34. 		case YOTO::ShaderDataType::Int2:
  35. 			return 4*2;
  36. 			break;
  37. 		case YOTO::ShaderDataType::Int3:
  38. 			return 4*3;
  39. 			break;
  40. 		case YOTO::ShaderDataType::Int4:
  41. 			return 4*4;
  42. 			break;
  43. 		case YOTO::ShaderDataType::Bool:
  44. 			return 1;
  45. 			break;
  46. 		}
  47. 		YT_CORE_ASSERT(false, "未知的ShaderDataType！");
  48. 		return 0;
  49. 	}
  50. 	struct BufferElement {
  51. 		std::string Name;
  52. 		ShaderDataType Type;
  53. 		uint32_t Size;
  54. 		uint32_t Offset;
  55. 		bool Normalized;
  56. 		BufferElement(){}
  57. 		BufferElement(ShaderDataType type, const std::string& name,bool normalized=false)
  58. 			:Name(name), Type(type), Size(ShaderDataTypeSize(type)), Offset(0), Normalized(normalized){}
  59. 		uint32_t GetComponentCount() const{
  60. 			switch (Type)
  61. 			{
  62. 			case YOTO::ShaderDataType::Float:
  63. 				return 1;
  64. 				break;
  65. 			case YOTO::ShaderDataType::Float2:
  66. 				return 2;
  67. 				break;
  68. 			case YOTO::ShaderDataType::Float3:
  69. 				return 3;
  70. 				break;
  71. 			case YOTO::ShaderDataType::Float4:
  72. 				return 4;
  73. 				break;
  74. 			case YOTO::ShaderDataType::Mat3:
  75. 				return 3*3;
  76. 				break;
  77. 			case YOTO::ShaderDataType::Mat4:
  78. 				return 4*4;
  79. 				break;
  80. 			case YOTO::ShaderDataType::Int:
  81. 				return 1;
  82. 				break;
  83. 			case YOTO::ShaderDataType::Int2:
  84. 				return 2;
  85. 				break;
  86. 			case YOTO::ShaderDataType::Int3:
  87. 				return 3;
  88. 				break;
  89. 			case YOTO::ShaderDataType::Int4:
  90. 				return 4;
  91. 				break;
  92. 			case YOTO::ShaderDataType::Bool:
  93. 				return 1;
  94. 				break;
  95. 			default:
  96. 				break;
  97. 			}
  98. 			YT_CORE_ASSERT(false, "未知的ShaderDataType！");
  99. 			return 0;
  100. 		}
  101. 	};
  102. 	class BufferLayout {
  103. 	public:
  104. 		BufferLayout(){}
  105. 		BufferLayout(const std::initializer_list<BufferElement>elements)
  106. 			:m_Elements(elements) 
  107. 		{
  108. 			CalculateOffsetAndStride();
  109. 		} 
  110. 		inline uint32_t GetStride()const { return m_Stride; }
  111. 		inline const std::vector<BufferElement>& GetElements()const {
  112. 			return m_Elements;
  113. 		}
  114. 		std::vector<BufferElement>::iterator begin() { return m_Elements.begin(); }
  115. 		std::vector<BufferElement>::iterator end() { return m_Elements.end(); }
  116. 		std::vector<BufferElement>::const_iterator begin() const { return m_Elements.begin(); }
  117. 		std::vector<BufferElement>::const_iterator end() const { return m_Elements.end(); }
  118. 	private:
  119. 		void CalculateOffsetAndStride() {
  120. 			uint32_t offset = 0;
  121. 			m_Stride = 0;
  122. 			for (auto& element : m_Elements) {
  123. 				element.Offset = offset;
  124. 				offset += element.Size;
  125. 				m_Stride += element.Size;
  126. 			}
  127. 		}
  128. 	private:
  129. 		std::vector<BufferElement> m_Elements;
  130. 		uint32_t m_Stride = 0;
  131. 	};
  132. 	class VertexBuffer {
  133. 	public:
  134. 		virtual~VertexBuffer() {}
  135.  
  136. 		virtual void Bind() const = 0;
  137. 		virtual void UnBind() const = 0;
  138.  
  139. 		virtual void SetData(const void* data, uint32_t size) = 0;
  140.  
  141. 		virtual void SetLayout(const BufferLayout& layout) = 0;
  142. 		virtual const BufferLayout& GetLayout()const = 0;
  143. 		
  144.  
  145. 		static  Ref<VertexBuffer> Create(float* vertices, uint32_t size);
  146. 		static  Ref<VertexBuffer> Create(uint32_t size);
  147. 	};
  148. 	/// <summary>
  149. 	/// 目前索引仅支持32位的索引缓冲区
  150. 	/// </summary>
  151. 	class IndexBuffer {
  152. 	public:
  153. 		virtual~IndexBuffer(){}
  154. 		virtual void Bind() const = 0;
  155. 		virtual void UnBind() const = 0;
  156. 		virtual uint32_t GetCount() const = 0;
  157. 		static  Ref<IndexBuffer> Create(uint32_t* indices, uint32_t count);
  158.  
  159. 	};
  160. }

Buffer.cpp:

  1. #include"ytpch.h"
  2. #include"Buffer.h"
  3. #include "Renderer.h"
  4.  
  5. #include "Platform/OpenGL/OpenGLBuffer.h"
  6.  
  7. namespace YOTO {
  8.  
  9. 	Ref<VertexBuffer> VertexBuffer::Create(uint32_t size)
  10. 	{
  11. 		switch (Renderer::GetAPI())
  12. 		{
  13. 		case RendererAPI::API::None:
  14. 			YT_CORE_ASSERT(false, "Buffer：API为None不支持");
  15. 			return nullptr;
  16. 		case RendererAPI::API::OpenGL:
  17. 			return std::make_shared<OpenGLVertexBuffer>(size);
  18. 		}
  19. 		YT_CORE_ASSERT(false, "Buffer：未知API");
  20. 		return nullptr;
  21. 	}
  22. 	Ref<VertexBuffer> VertexBuffer::Create(float* vertices, uint32_t size)
  23. 	{
  24. 		switch (Renderer::GetAPI())
  25. 		{
  26. 		case RendererAPI::API::None:
  27. 			YT_CORE_ASSERT(false,"Buffer：API为None不支持");
  28. 			return nullptr;
  29. 		case RendererAPI::API::OpenGL:
  30. 			return std::make_shared<OpenGLVertexBuffer>(vertices,size);
  31. 		}
  32. 		YT_CORE_ASSERT(false,"Buffer：未知API");
  33. 		return nullptr;
  34. 	}
  35.  
  36. 	Ref<IndexBuffer> IndexBuffer::Create(uint32_t* indices, uint32_t count)
  37. 	{
  38. 		switch (Renderer::GetAPI())
  39. 		{
  40. 		case RendererAPI::API::None:
  41. 			YT_CORE_ASSERT(false, "Buffer：API为None不支持");
  42. 			return nullptr;
  43. 		case RendererAPI::API::OpenGL:
  44. 			return std::make_shared < OpenGLIndexBuffer>(indices, count);
  45. 		}
  46. 		YT_CORE_ASSERT(false, "Buffer：未知API");
  47. 		return nullptr;
  48. 	}
  49.  
  50. }

OpenGLBuffer.cpp: 实现继承自Buffer的方法

  1. #include"ytpch.h"
  2. #include"OpenGLBuffer.h"
  3. #include <glad/glad.h>
  4. namespace YOTO {
  5.  
  6. 	
  7. 	// VertexBuffer 
  8. 	
  9.  
  10. 	OpenGLVertexBuffer::OpenGLVertexBuffer(uint32_t size)
  11. 	{
  12. 		YT_PROFILE_FUNCTION();
  13. 		glCreateBuffers(1, &m_RendererID);
  14. 		glBindBuffer(GL_ARRAY_BUFFER, m_RendererID);
  15. 		glBufferData(GL_ARRAY_BUFFER, size, nullptr, GL_DYNAMIC_DRAW);
  16. 	}
  17. 	OpenGLVertexBuffer::OpenGLVertexBuffer(float* vertices, uint32_t size)
  18. 	{	 
  19. 		YT_PROFILE_FUNCTION();
  20. 		glCreateBuffers(1, &m_RendererID);
  21. 		glBindBuffer(GL_ARRAY_BUFFER, m_RendererID);
  22. 		glBufferData(GL_ARRAY_BUFFER, size, vertices, GL_STATIC_DRAW);
  23. 	}
  24. 	OpenGLVertexBuffer::~OpenGLVertexBuffer()
  25. 	{
  26. 		YT_PROFILE_FUNCTION();
  27. 		glDeleteBuffers(1, &m_RendererID);
  28. 	}
  29. 	void OpenGLVertexBuffer::Bind() const
  30. 	{
  31. 		YT_PROFILE_FUNCTION();
  32. 		glBindBuffer(GL_ARRAY_BUFFER, m_RendererID);
  33. 	}
  34. 	void OpenGLVertexBuffer::UnBind() const
  35. 	{
  36. 		glBindBuffer(GL_ARRAY_BUFFER, 0);
  37. 	}
  38.  
  39. 	void OpenGLVertexBuffer::SetData(const void* data, uint32_t size)
  40. 	{
  41. 		glBindBuffer(GL_ARRAY_BUFFER, m_RendererID);
  42. 		// 用来更新一个已有缓冲区对象中的一部分数据，
  43. 		//data:一个指向新数据源的指针，将新的数据源拷贝到缓冲区对象中完成更新
  44. 		glBufferSubData(GL_ARRAY_BUFFER,0,size,data);
  45. 	}
  46.  
  47. 	
  48. 	// IndexBuffer /
  49. 	
  50. 	OpenGLIndexBuffer::OpenGLIndexBuffer(uint32_t* indices, uint32_t count)
  51. 		:m_Count(count)
  52. 	{
  53. 		YT_PROFILE_FUNCTION();
  54. 		glCreateBuffers(1, &m_RendererID);
  55. 		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_RendererID);
  56. 		glBufferData(GL_ELEMENT_ARRAY_BUFFER, count*sizeof(uint32_t), indices, GL_STATIC_DRAW);
  57. 	}
  58. 	OpenGLIndexBuffer::~OpenGLIndexBuffer()
  59. 	{
  60. 		YT_PROFILE_FUNCTION();
  61. 		glDeleteBuffers(1, &m_RendererID);
  62. 	}
  63. 	void OpenGLIndexBuffer::Bind() const
  64. 	{
  65. 		YT_PROFILE_FUNCTION();
  66. 		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_RendererID);
  67. 	}
  68. 	void OpenGLIndexBuffer::UnBind() const
  69. 	{
  70. 		YT_PROFILE_FUNCTION();
  71. 		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
  72. 	}
  73. }

RenderAPI.h:创建DrawIndexed方法根据索引绘制图像：

  1. #pragma once
  2. #include<glm/glm.hpp>
  3. #include "VertexArray.h"
  4. namespace YOTO {
  5. 	class RendererAPI
  6. 	{
  7. 	public:
  8. 		enum class API {
  9. 			None = 0,
  10. 			OpenGL = 1
  11. 		};
  12. 	public:
  13. 		virtual void Init() = 0;
  14. 		virtual void SetClearColor(const glm::vec4& color)=0;
  15. 		virtual void SetViewport(uint32_t x, uint32_t y, uint32_t width, uint32_t height) = 0;
  16. 		virtual void Clear() = 0;
  17. 		virtual void DrawIndexed(const Ref<VertexArray>& vertexArray,uint32_t indexCount = 0)=0;
  18.  
  19. 		inline static API GetAPI() { return s_API; }
  20. 	private:
  21. 		static API s_API;
  22. 	};
  23. }
  24.  
  25.

OpenGLRendererAPI.cpp: 

  1. #include "ytpch.h"
  2. #include "OpenGLRendererAPI.h"
  3. #include <glad/glad.h>
  4. namespace YOTO {
  5. 	void OpenGLRendererAPI::Init()
  6. 	{
  7. 		YT_PROFILE_FUNCTION();
  8. 		//启用混合
  9. 		glEnable(GL_BLEND);
  10. 		//设置混合函数
  11. 		glBlendFunc(GL_SRC_ALPHA,GL_ONE_MINUS_SRC_ALPHA);
  12. 		//深度测试
  13. 		glEnable(GL_DEPTH_TEST);
  14. 	}
  15. 	void OpenGLRendererAPI::SetViewport(uint32_t x, uint32_t y, uint32_t width, uint32_t height)
  16. 	{
  17. 		glViewport(x, y, width, height);
  18. 	}
  19. 	void OpenGLRendererAPI::SetClearColor(const glm::vec4& color)
  20. 	{
  21. 		glClearColor(color.r, color.g, color.b, color.a);
  22. 	}
  23. 	void OpenGLRendererAPI::Clear()
  24. 	{
  25. 		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  26. 	}
  27. 	void OpenGLRendererAPI::DrawIndexed(const Ref<VertexArray>& vertexArray, uint32_t indexCount)
  28. 	{
  29. 		uint32_t count = indexCount ? vertexArray->GetIndexBuffer()->GetCount() : indexCount;
  30. 		glDrawElements(GL_TRIANGLES, count, GL_UNSIGNED_INT, nullptr);
  31. 		glBindTexture(GL_TEXTURE_2D, 0);
  32. 	}
  33. }

RenderCommand.h: 对API的DrawIndexed封装：

  1. #pragma once
  2. #include"RendererAPI.h"
  3. namespace YOTO {
  4. 	class RenderCommand
  5. 	{
  6. 	public:
  7. 		inline static void Init() {
  8. 			s_RendererAPI->Init();
  9. 		}
  10. 		inline static void SetViewport(uint32_t x, uint32_t y, uint32_t width, uint32_t height) {
  11. 			s_RendererAPI->SetViewport(x,y,width,height);
  12. 		}
  13.  
  14. 		inline static void SetClearColor(const glm::vec4& color) {
  15. 			s_RendererAPI->SetClearColor(color);
  16. 		}
  17. 		inline static void Clear() {
  18. 			s_RendererAPI->Clear();
  19. 		}
  20. 		inline static void DrawIndexed(const Ref<VertexArray>& vertexArray,uint32_t count=0) {
  21. 			s_RendererAPI->DrawIndexed(vertexArray, count);
  22. 		}
  23. 		
  24. 	private:
  25. 		static RendererAPI* s_RendererAPI;
  26.  
  27. 	};
  28.  
  29. }
  30.

 调用：

Texture.glsl：先改下shader

  1. #type vertex
  2. #version 330 core
  3.  
  4. layout(location = 0) in vec3 a_Position;
  5. layout(location = 1) in vec4 a_Color;
  6. layout(location = 2) in vec2 a_TexCoord;
  7.  
  8. uniform mat4 u_ViewProjection;
  9. // uniform mat4 u_Transform;
  10.  
  11. out vec4 v_Color;
  12. out vec2 v_TexCoord;
  13.  
  14. void main() {
  15. 	v_Color = a_Color;
  16. 	v_TexCoord = a_TexCoord;
  17.     // 由规则动态生成的顶点位置（基于本地空间）没有涉及transform变换顶点位置
  18.     // gl_Position = u_ViewProjection * u_Transform * vec4(a_Position, 1.0); 
  19. 	gl_Position = u_ViewProjection * vec4(a_Position, 1.0);
  20. }
  21. #type fragment
  22. #version 330 core
  23.  
  24. layout(location = 0) out vec4 color;
  25.  
  26. in vec4 v_Color;
  27. in vec2 v_TexCoord;
  28.  
  29. uniform vec4 u_Color;
  30. uniform float u_TilingFactor;
  31.  
  32. uniform sampler2D u_Texture;
  33.  
  34. void main() {
  35. 	color = v_Color;
  36. }

Sandbox2D.cpp:

  1. #include "Sandbox2D.h"
  2. #include <imgui/imgui.h>
  3. #include <glm/gtc/matrix_transform.hpp>
  4. //#include <Platform/OpenGL/OpenGLShader.h>
  5. #include <glm/gtc/type_ptr.hpp>
  6. #include<vector>
  7. #include<chrono>
  8. template<typename Fn>
  9. class Timer {
  10. public:
  11. 	Timer(const char* name, Fn&&func)
  12. 		:m_Name(name),m_Func(func),m_Stopped(false)
  13. 	{
  14. 		m_StartTimepoint = std::chrono::high_resolution_clock::now();
  15. 	}
  16. 	~Timer() {
  17. 		if (!m_Stopped) {
  18. 			Stop();
  19. 		}
  20. 	}
  21. 	void Stop() {
  22. 		auto endTimepoint= std::chrono::high_resolution_clock::now();
  23. 		long long start = std::chrono::time_point_cast<std::chrono::microseconds>(m_StartTimepoint).time_since_epoch().count();
  24. 		long long end = std::chrono::time_point_cast<std::chrono::microseconds>(endTimepoint).time_since_epoch().count();
  25. 		m_Stopped = true;
  26. 		float duration = (end - start)*0.001f;
  27. 		m_Func({m_Name,duration});
  28. 		//std::cout << "Timer:"<< m_Name << "时差：" << duration << "ms" << std::endl;
  29. 	}
  30. private:
  31. 	const char* m_Name;
  32. 	std::chrono::time_point<std::chrono::steady_clock>m_StartTimepoint;
  33. 	bool m_Stopped;
  34. 	Fn m_Func;
  35. };
  36. //未找到匹配的重载：auto的问题，改回原来的类型就好了
  37. #define PROFILE_SCOPE(name) Timer timer##__LINE__(name,[&](ProfileResult profileResult) {m_ProfileResults.push_back(profileResult);})
  38. Sandbox2D::Sandbox2D()
  39. :Layer("Sandbox2D"), m_CameraController(1280.0f / 720.0f, true) 
  40. {
  41. }
  42. void Sandbox2D::OnAttach()
  43. {
  44. 	YT_PROFILE_FUNCTION();
  45. 	m_CheckerboardTexture = YOTO::Texture2D::Create("assets/textures/Checkerboard.png");
  46.  
  47. }
  48. void Sandbox2D::OnDetach()
  49. {
  50. 	YT_PROFILE_FUNCTION();
  51. }
  52.  
  53. void Sandbox2D::OnUpdate(YOTO::Timestep ts)
  54. {
  55. 	YT_PROFILE_FUNCTION();
  56. 		//update
  57. 		m_CameraController.OnUpdate(ts);
  58. 	
  59. 	
  60. 	{
  61. 		YT_PROFILE_SCOPE("Sandbox2D::Renderer Prep");
  62. 		//Render
  63. 		YOTO::RenderCommand::SetClearColor({ 0.2f, 0.2f, 0.2f, 1.0f });
  64. 		YOTO::RenderCommand::Clear();
  65. 	}
  66. 	
  67. 	{
  68. 		YT_PROFILE_SCOPE("Sandbox2D::Renderer Draw");
  69. 		YOTO::Renderer2D::BeginScene(m_CameraController.GetCamera());
  70. 		{
  71. 	/*		static glm::mat4 scale = glm::scale(glm::mat4(1.0f), glm::vec3(0.1f));
  72. 			glm::vec4  redColor(0.8f, 0.3f, 0.3f, 1.0f);
  73. 			glm::vec4  blueColor(0.2f, 0.3f, 0.8f, 1.0f);*/
  74.  
  75.  
  76. 			/*std::dynamic_pointer_cast<YOTO::OpenGLShader>(m_FlatColorShader)->Bind();
  77. 			std::dynamic_pointer_cast<YOTO::OpenGLShader>(m_FlatColorShader)->UploadUniformFloat4("u_Color", m_SquareColor);
  78. 			YOTO::Renderer::Submit(m_FlatColorShader, m_SquareVA, glm::scale(glm::mat4(1.0f), glm::vec3(1.5f)));*/
  79.  
  80. 		//	YOTO::Renderer2D::DrawRotatedQuad({ -1.0f,0.0f }, { 0.8f,0.8f }, glm::radians(45.0f),{ 0.8f,0.2f,0.3f,1.0f });
  81. 			YOTO::Renderer2D::DrawQuad({ -1.0f,0.0f }, { 0.8f,0.8f }, { 0.8f,0.2f,0.3f,1.0f });
  82. 			YOTO::Renderer2D::DrawQuad({ 0.5f,-0.5f }, { 0.5f,0.75f }, { 0.2f,0.3f,0.8f,1.0f });
  83. 			//YOTO::Renderer2D::DrawQuad({ 0.0f,0.0f,-0.1f }, { 10.0f,10.0f }, m_CheckerboardTexture,10.0f,glm::vec4(1.0f,0.9f,0.9f,1.0f));
  84. 			YOTO::Renderer2D::EndScene();
  85. 		}
  86. 	}
  87. 	
  88. }
  89. void Sandbox2D::OnImGuiRender()
  90. {
  91. 	YT_PROFILE_FUNCTION();
  92. 	ImGui::Begin("Setting");
  93. 	ImGui::ColorEdit4("Color", glm::value_ptr(m_SquareColor));
  94. 	for (auto& res : m_ProfileResults) {
  95. 		char lable[50];
  96. 		strcpy(lable, "%.3fms  ");
  97. 		strcat(lable, res.Name);
  98. 		ImGui::Text(lable, res.Time);
  99. 	}
  100. 	m_ProfileResults.clear();
  101. 	ImGui::End();
  102. }
  103.  
  104. void Sandbox2D::OnEvent(YOTO::Event& e)
  105. {
  106. 	YT_PROFILE_FUNCTION();
  107. 	m_CameraController.OnEvent(e);
  108. }

cool！ 

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/花生_TL007/article/detail/341495
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号