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

跟着cherno手搓游戏引擎【25】封装2DRenderer，封装shader传参，自定义Texture

作者：2023面试高手 | 2024-02-23 11:03:57

赞

踩

跟着cherno手搓游戏引擎【25】封装2DRenderer，封装shader传参，自定义Texture

封装2DRenderer：

Renderer.h:

  1. #include"ytpch.h"
  2. #include"Renderer.h"
  3. #include <Platform/OpenGL/OpenGLShader.h>
  4. #include"Renderer2D.h"
  5. namespace YOTO {
  6. 	Renderer::SceneData* Renderer::m_SceneData = new	Renderer::SceneData;
  7. 	void Renderer::Init()
  8. 	{
  9. 		RenderCommand::Init();
  10. 		Renderer2D::Init();
  11. 	}
  12. 	void Renderer::OnWindowResize(uint32_t width, uint32_t height)
  13. 	{
  14. 		RenderCommand::SetViewport(0, 0, width, height);
  15. 	}
  16. 	void Renderer::BeginScene(OrthographicCamera& camera)
  17. 	{
  18. 		m_SceneData->ViewProjectionMatrix = camera.GetViewProjectionMatrix();
  19. 	}
  20. 	void Renderer::EndScene()
  21. 	{
  22. 	}
  23. 	void Renderer::Submit(const Ref<Shader>& shader, const Ref<VertexArray>& vertexArray, const glm::mat4& transform)
  24. 	{
  25. 		shader->Bind();
  26. 		std::dynamic_pointer_cast<OpenGLShader>(shader)->UploadUniformMat4("u_ViewProjection", m_SceneData->ViewProjectionMatrix);
  27. 		std::dynamic_pointer_cast<OpenGLShader>(shader)->UploadUniformMat4("u_Transform", transform);
  28. 	/*	mi.Bind();*/
  29.  
  30. 		vertexArray->Bind();
  31. 		RenderCommand::DrawIndexed(vertexArray);
  32. 	}
  33. }

Renderer2D.h:专门渲染2D的类，负责“画什么”的问题

  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 DrawQuad(const glm::vec2& position, const glm::vec2& size, const glm::vec4& color);
  14. 		static void DrawQuad(const glm::vec3& position, const glm::vec2& size, const glm::vec4& color);
  15. 		static void DrawQuad(const glm::vec2& position, const glm::vec2& size, const Ref<Texture2D> texture);
  16. 		static void DrawQuad(const glm::vec3& position, const glm::vec2& size, const Ref<Texture2D> texture);
  17. 	private:
  18. 	private:
  19.  
  20. 	};
  21. }
  22.  
  23.

 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. 	struct  Renderer2DStorage {
  10. 		Ref<VertexArray> QuadVertexArray;
  11. 		//Ref<Shader> FlatColorShader;
  12. 		Ref<Shader> TextureShader;
  13. 		Ref<Texture2D> WhiteTexture;
  14. 	};
  15. 	static Renderer2DStorage* s_Data;
  16. 	void Renderer2D::Init()
  17. 	{
  18. 		s_Data = new  Renderer2DStorage();
  19. 		s_Data->QuadVertexArray = VertexArray::Create();
  20.  
  21. 		float squareVertices[5 * 4] = {
  22. 			-0.5f,-0.5f,0.0f,0.0f,0.0f,
  23. 			0.5f,-0.5f,0.0f,1.0f,0.0f,
  24. 			0.5f,0.5f,0.0f,1.0f,1.0f,
  25. 			-0.5f,0.5f,0.0f,0.0f,1.0f,
  26. 		};
  27. 		Ref<VertexBuffer> squareVB;
  28. 		squareVB.reset(VertexBuffer::Create(squareVertices, sizeof(squareVertices)));
  29. 		squareVB->SetLayout({
  30. 			{ShaderDataType::Float3,"a_Position"},
  31. 				{ShaderDataType::Float2,"a_TexCoord"}
  32. 			});
  33. 		s_Data->QuadVertexArray->AddVertexBuffer(squareVB);
  34. 		uint32_t squareIndices[6] = { 0,1,2,2,3,0 };
  35. 		Ref<IndexBuffer> squareIB;
  36.  
  37. 		squareIB.reset((IndexBuffer::Create(squareIndices, sizeof(squareIndices) / sizeof(uint32_t))));
  38.  
  39. 		s_Data->QuadVertexArray->AddIndexBuffer(squareIB);
  40.  
  41. 		s_Data->WhiteTexture = Texture2D::Create(1, 1);
  42. 		uint32_t whiteTextureData = 0xffffffff;
  43. 		s_Data->WhiteTexture->SetData(&whiteTextureData,sizeof(uint32_t));
  44.  
  45. 		//s_Data->FlatColorShader =Shader::Create("assets/shaders/FlatColor.glsl");
  46. 		s_Data->TextureShader= Shader::Create("assets/shaders/Texture.glsl");
  47. 		s_Data->TextureShader->Bind();
  48. 		s_Data->TextureShader->SetInt("u_Texture", 0);
  49.  
  50. 	}
  51. 	void Renderer2D::ShutDown()
  52. 	{
  53. 		delete s_Data;
  54. 	}
  55. 	void Renderer2D::BeginScene(const OrthographicCamera& camera)
  56. 	{
  57. 		/*s_Data->FlatColorShader->Bind();
  58. 		s_Data->FlatColorShader->SetMat4("u_ViewProjection",camera.GetViewProjectionMatrix());*/
  59. 		s_Data->TextureShader->Bind();
  60. 		s_Data->TextureShader->SetMat4("u_ViewProjection", camera.GetViewProjectionMatrix());
  61. 	
  62. 	}
  63. 	void Renderer2D::EndScene()
  64. 	{
  65. 	}
  66. 	void Renderer2D::DrawQuad(const glm::vec2& position, const glm::vec2& size, const glm::vec4& color)
  67. 	{
  68. 		DrawQuad({ position.x,position.y,0.0f }, size, color);
  69. 	}
  70. 	void Renderer2D::DrawQuad(const glm::vec3& position, const glm::vec2& size, const glm::vec4& color)
  71. 	{
  72. 		//s_Data->FlatColorShader->Bind();
  73. 		//s_Data->FlatColorShader->SetFloat4("u_Color", color);
  74. 		//s_Data->TextureShader->Bind();
  75. 		s_Data->TextureShader->SetFloat4("u_Color", color);
  76. 		s_Data->WhiteTexture->Bind();
  77.  
  78. 		glm::mat4 transform = glm::translate(glm::mat4(1.0f), position) /**rotation*/ * glm::scale(glm::mat4(1.0f), {size.x,size.y,1.0f});
  79. 		s_Data->TextureShader->SetMat4("u_Transform", transform);
  80. 		s_Data->QuadVertexArray->Bind();
  81. 		RenderCommand::DrawIndexed(s_Data->QuadVertexArray);
  82. 	}
  83. 	void Renderer2D::DrawQuad(const glm::vec2& position, const glm::vec2& size, const Ref<Texture2D> texture)
  84. 	{
  85. 		DrawQuad({ position.x,position.y,0.0f }, size, texture);
  86. 	}
  87. 	void Renderer2D::DrawQuad(const glm::vec3& position, const glm::vec2& size, const Ref<Texture2D> texture)
  88. 	{
  89. 		//s_Data->TextureShader->Bind();
  90. 		s_Data->TextureShader->SetFloat4("u_Color", {0.2f,0.3f,0.8f,0.5f});
  91. 		texture->Bind();
  92.  
  93.  
  94. 		glm::mat4 transform = glm::translate(glm::mat4(1.0f), position) /**rotation*/ * glm::scale(glm::mat4(1.0f), { size.x,size.y,1.0f });
  95. 		s_Data->TextureShader->SetMat4("u_Transform", transform);
  96.  
  97. 		s_Data->QuadVertexArray->Bind();
  98. 		RenderCommand::DrawIndexed(s_Data->QuadVertexArray);
  99. 		
  100. 	}
  101. }

封装Shader传参：

Shader.h:添加SetInt、SetFloat3...等等Set方法

  1. #pragma once
  2. #include <string>
  3. #include<glm/glm.hpp>
  4. namespace YOTO {
  5.  
  6. 	class Shader {
  7.  
  8. 	public:
  9. 		virtual~Shader()=default;
  10. 		virtual void Bind()const=0;
  11. 		virtual void UnBind()const=0;
  12.  
  13. 		virtual void SetInt(const std::string& name,int value) = 0;
  14. 		virtual void SetFloat3(const std::string& name, const glm::vec3& value) = 0;
  15. 		virtual void SetFloat4(const std::string& name, const glm::vec4& value) = 0;
  16. 		virtual void SetMat4(const std::string& name, const glm::mat4& value) = 0;
  17.  
  18. 		virtual const std::string& GetName()const = 0;
  19.  
  20. 		static Ref<Shader> Create(const std::string& filepath);
  21. 		static Ref<Shader> Create(const std::string&name, const std::string& vertexSrc, const std::string& fragmentSrc);
  22.  
  23. 	};
  24. 	class ShaderLibrary {
  25. 	public:
  26. 		void Add(const Ref<Shader>& shader);
  27. 		void Add(const std::string &name,const Ref<Shader>& shader);
  28. 		Ref<Shader> Load(const std::string filepath);
  29. 		Ref<Shader> Load(const std::string &name,const std::string filepath);
  30. 		Ref<Shader> Get(const std::string& name);
  31. 		bool Exists(const std::string& name);
  32. 	private:
  33. 		std::unordered_map<std::string,Ref<Shader>> m_Shaders;
  34.  
  35. 	};
  36. }

OpenGLShader.h:同Shader.h

  1. #pragma once
  2. #include <string>
  3. #include "YOTO/Renderer/Shader.h"
  4. #include <glm/glm.hpp>
  5. typedef unsigned int GLenum;
  6. namespace YOTO {
  7.  
  8. 	class OpenGLShader:public Shader {
  9.  
  10. 	public:
  11. 		OpenGLShader(const std::string& filepath);
  12. 		OpenGLShader(const std::string &name,const std::string& vertexSrc, const std::string& fragmentSrc);
  13. 		~OpenGLShader();
  14. 		void Bind()const override;
  15. 		void UnBind()const override;
  16.  
  17. 		virtual void SetInt(const std::string& name, int value) override;
  18. 		virtual void SetFloat3(const std::string& name, const glm::vec3& value) override;
  19. 		virtual void SetFloat4(const std::string& name, const glm::vec4& value)override;
  20. 		virtual void SetMat4(const std::string& name, const glm::mat4& value) override;
  21.  
  22. 		virtual const std::string& GetName()const override { return m_Name; }
  23. 		void UploadUniformMat4(const std::string& name, const glm::mat4& matrix);
  24. 		void UploadUniformMat3(const std::string& name, const glm::mat3& matrix);
  25.  
  26. 		void UploadUniformFloat4(const std::string& name, const glm::vec4& values);
  27. 		void UploadUniformFloat3(const std::string& name, const glm::vec3& values);
  28. 		void UploadUniformFloat2(const std::string& name, const glm::vec2& values);
  29. 		void UploadUniformFloat(const std::string& name, float values);
  30.  
  31. 		void UploadUniformInt(const std::string& name, int values);
  32. 	private:
  33. 		std::string ReadFile(const std::string filepath);
  34. 		std::unordered_map<GLenum,std::string> PreProcess(const std::string& source);
  35. 		void Compile(const std::unordered_map<GLenum, std::string>& shaderSources);
  36. 	private:
  37. 		uint32_t m_RendererID;
  38. 		std::string m_Name;
  39. 	}
  40. 	;
  41. }

OpenGLShader.cpp: 

  1. #include "ytpch.h"
  2. #include "OpenGLShader.h"
  3.  
  4. #include <glad/glad.h>
  5. #include<glm/gtc/type_ptr.hpp>
  6. namespace YOTO {
  7. 	static GLenum ShaderTypeFromString(const std::string& type) {
  8. 		if (type == "vertex") {
  9. 			return GL_VERTEX_SHADER;
  10. 		}
  11. 		if (type == "fragment" || type == "pixel") {
  12. 			return GL_FRAGMENT_SHADER;
  13. 		}
  14. 		YT_CORE_ASSERT(false, "不知道的shader类型");
  15. 		return 0;
  16. 	}
  17. 	
  18. 	OpenGLShader::OpenGLShader(const std::string& filepath)
  19. 	{
  20. 		std::string source = ReadFile(filepath);
  21. 		YT_CORE_ASSERT(source.size(), "GLSL读取的字符串为空");
  22. 		auto shaderSources = PreProcess(source);
  23. 		Compile(shaderSources);
  24.  
  25.  
  26. 		auto lastSlash = filepath.find_last_of("/\\");
  27. 		lastSlash = lastSlash == std::string::npos ? 0 : lastSlash + 1;
  28. 		auto lastDot = filepath.rfind('.');
  29. 		auto count = lastDot == std::string::npos ? filepath.size() - lastSlash : lastDot - lastSlash;
  30. 		m_Name=filepath.substr(lastSlash, count);
  31. 	}
  32. 	OpenGLShader::OpenGLShader(const std::string& name, const std::string& vertexSrc, const std::string& fragmentSrc)
  33. 	:m_Name(name){
  34. 		std::unordered_map<GLenum, std::string >sources;
  35. 		sources[GL_VERTEX_SHADER] = vertexSrc;
  36. 		sources[GL_FRAGMENT_SHADER] = fragmentSrc;
  37. 		Compile(sources);
  38. 	}
  39. 	OpenGLShader::~OpenGLShader()
  40. 	{
  41. 		glDeleteProgram(m_RendererID);
  42. 	}
  43.  
  44. 	std::string OpenGLShader::ReadFile(const std::string filepath)
  45. 	{
  46. 		std::string result;
  47. 		std::ifstream in(filepath, std::ios::in | std::ios::binary);
  48. 		if (in) {
  49. 			in.seekg(0, std::ios::end);			// 将指针放在最后面
  50. 			result.resize(in.tellg());			// 初始化string的大小, in.tellg()返回位置
  51. 			in.seekg(0, std::ios::beg);			// in指回头部
  52. 			in.read(&result[0], result.size());	// in读入放在result指向的内存中
  53. 		}
  54. 		else {
  55. 			YT_CORE_ERROR("不能打开文件:{0}", filepath);
  56. 		}
  57. 		return result;
  58. 	}
  59. 	std::unordered_map<GLenum, std::string> OpenGLShader::PreProcess(const std::string& source)
  60. 	{
  61. 		std::unordered_map<GLenum, std::string> shaderSources;
  62.  
  63. 		std::string typeToken = "#type";
  64. 		size_t typeTokenLen = typeToken.size();
  65. 		size_t findCurPos = source.find(typeToken, 0);
  66. 		size_t findNextPos = findCurPos;
  67. 		while (findNextPos != std::string::npos) {
  68. 			size_t curlineEndPos = source.find_first_of("\r\n", findCurPos);///r/n写错为/r/n
  69. 			YT_CORE_ASSERT(curlineEndPos != std::string::npos, "解析shader失败");
  70. 			size_t begin = findCurPos + typeTokenLen + 1;
  71.  
  72. 			std::string type = source.substr(begin, curlineEndPos - begin);// 获取到是vertex还是fragment
  73. 			YT_CORE_ASSERT(ShaderTypeFromString(type), "无效的shader的类型	");
  74.  
  75. 			size_t nextLinePos = source.find_first_not_of("\r\n", curlineEndPos);
  76. 			findNextPos = source.find(typeToken, nextLinePos);
  77. 			// 获取到具体的shader代码
  78. 			shaderSources[ShaderTypeFromString(type)] = source.substr(nextLinePos, findNextPos - (nextLinePos == std::string::npos ? source.size() - 1 : nextLinePos));
  79.  
  80. 			findCurPos = findNextPos;
  81. 		}
  82. 		return shaderSources;
  83. 		/*
  84. 			用find，而不是find_firtst_of，因为
  85. 			find返回完全匹配的字符串的的位置；
  86. 			find_first_of返回被查匹配字符串中某个字符的第一次出现位置。
  88. 			std::string::npos是一个非常大的数
  89. 			source.substr(0, source.size() + 10000)截取到从头到末尾，不会报错
  90. 		*/
  91. 	}
  92.  
  93. 	void OpenGLShader::Compile(const std::unordered_map<GLenum, std::string>& shaderSources)
  94. 	{
  95. 		GLuint program = glCreateProgram();
  96. 		YT_CORE_ASSERT(shaderSources.size()<=2,"OpenGLShader：shader只支持两种！")
  97. 		std::array<GLenum,2>glShaderIDs;
  98. 		int glShaderIDIndex=0;
  99. 		for (auto& kv : shaderSources) {
  100. 			GLenum type = kv.first;
  101. 			const std::string& source = kv.second;
  102. 			// Create an empty vertex shader handle
  103. 			GLuint shader = glCreateShader(type);
  104. 			// Send the vertex shader source code to GL
  105. 			// Note that std::string's .c_str is NULL character terminated.
  106. 			const GLchar* sourceCStr = source.c_str();
  107. 			glShaderSource(shader, 1, &sourceCStr, 0);
  108. 			// Compile the vertex shader
  109. 			glCompileShader(shader);
  110. 			GLint isCompiled = 0;
  111. 			glGetShaderiv(shader, GL_COMPILE_STATUS, &isCompiled);
  112. 			if (isCompiled == GL_FALSE)
  113. 			{
  114. 				GLint maxLength = 0;
  115. 				glGetShaderiv(shader, GL_INFO_LOG_LENGTH, &maxLength);
  116. 				// The maxLength includes the NULL character
  117. 				std::vector<GLchar> infoLog(maxLength);
  118. 				glGetShaderInfoLog(shader, maxLength, &maxLength, &infoLog[0]);
  119. 				// We don't need the shader anymore.
  120. 				glDeleteShader(shader);
  121. 				// Use the infoLog as you see fit.
  122. 				// In this simple program, we'll just leave
  123. 				YT_CORE_ERROR("{0} ", infoLog.data());
  124. 				YT_CORE_ASSERT(false, "shader 编译失败!");
  125. 				break;
  126. 			}
  127. 			// Attach our shaders to our program
  128. 			glAttachShader(program, shader);
  129. 			glShaderIDs[glShaderIDIndex++]=shader;
  130. 		}
  131.  
  132. 		// Link our program
  133. 		glLinkProgram(program);
  134. 		// Note the different functions here: glGetProgram* instead of glGetShader*.
  135. 		GLint isLinked = 0;
  136. 		glGetProgramiv(program, GL_LINK_STATUS, (int*)&isLinked);
  137. 		if (isLinked == GL_FALSE)
  138. 		{
  139. 			GLint maxLength = 0;
  140. 			glGetProgramiv(program, GL_INFO_LOG_LENGTH, &maxLength);
  141. 			// The maxLength includes the NULL character
  142. 			std::vector<GLchar> infoLog(maxLength);
  143. 			glGetProgramInfoLog(program, maxLength, &maxLength, &infoLog[0]);
  144. 			// We don't need the program anymore.
  145. 			glDeleteProgram(program);
  146. 			// Don't leak shaders either.
  147. 			for (auto id : glShaderIDs) {
  148. 				glDeleteShader(id);
  149. 			}
  150. 			// Use the infoLog as you see fit.
  151. 			// In this simple program, we'll just leave
  152. 			YT_CORE_ERROR("{0} ", infoLog.data());
  153. 			YT_CORE_ASSERT(false, "shader link failure!");
  154. 			return;
  155. 		}
  156. 		// Always detach shaders after a successful link.
  157. 		for (auto id : glShaderIDs) {
  158. 			glDetachShader(program, id);
  159. 		}
  160. 		m_RendererID = program;
  161.  
  162. 	}
  163.  
  164. 	void OpenGLShader::Bind() const
  165. 	{
  166. 		glUseProgram(m_RendererID);
  167. 	}
  168. 	void OpenGLShader::UnBind() const
  169. 	{
  170. 		glUseProgram(0);
  171. 	}
  172. 	void OpenGLShader::SetInt(const std::string& name, int value)
  173. 	{
  174. 		UploadUniformInt(name, value);
  175. 	}
  176. 	void OpenGLShader::SetFloat3(const std::string& name, const glm::vec3& value)
  177. 	{
  178. 		UploadUniformFloat3(name, value);
  179. 	}
  180. 	void OpenGLShader::SetFloat4(const std::string& name, const glm::vec4& value)
  181. 	{
  182. 		UploadUniformFloat4(name, value);
  183. 	}
  184. 	void OpenGLShader::SetMat4(const std::string& name, const glm::mat4& value)
  185. 	{
  186. 		UploadUniformMat4(name, value);
  187. 	}
  188. 	void OpenGLShader::UploadUniformMat4(const std::string& name, const glm::mat4& matrix)
  189. 	{
  190. 		GLint loacation = glGetUniformLocation(m_RendererID, name.c_str());
  191. 		glUniformMatrix4fv(loacation, 1, GL_FALSE, glm::value_ptr(matrix));
  192.  
  193. 	}
  194. 	void OpenGLShader::UploadUniformMat3(const std::string& name, const glm::mat3& matrix)
  195. 	{
  196. 		GLint loacation = glGetUniformLocation(m_RendererID, name.c_str());
  197. 		glUniformMatrix3fv(loacation, 1, GL_FALSE, glm::value_ptr(matrix)); 
  198. 	}
  199. 	void OpenGLShader::UploadUniformFloat4(const std::string& name, const glm::vec4& values)
  200. 	{
  201. 		GLint loacation = glGetUniformLocation(m_RendererID, name.c_str());
  202. 		glUniform4f(loacation, values.x, values.y, values.z, values.w);
  203.  
  204. 	}
  205. 	void OpenGLShader::UploadUniformFloat3(const std::string& name, const glm::vec3& values)
  206. 	{
  207. 		GLint loacation = glGetUniformLocation(m_RendererID, name.c_str());
  208. 		glUniform3f(loacation, values.x, values.y, values.z);
  209. 	}
  210. 	void OpenGLShader::UploadUniformFloat2(const std::string& name, const glm::vec2& values)
  211. 	{
  212. 		GLint loacation = glGetUniformLocation(m_RendererID, name.c_str());
  213. 		glUniform2f(loacation, values.x, values.y);
  214. 	}
  215. 	void OpenGLShader::UploadUniformFloat(const std::string& name, float values)
  216. 	{
  217. 		GLint loacation = glGetUniformLocation(m_RendererID, name.c_str());
  218. 		glUniform1f(loacation, values);
  219. 	}
  220. 	void OpenGLShader::UploadUniformInt(const std::string& name, int values)
  221. 	{
  222. 		GLint loacation = glGetUniformLocation(m_RendererID, name.c_str());
  223. 		glUniform1i(loacation, values);
  224. 	}
  225. 	
  226. }

添加自定义Texture方法：

Texture.h:添加新的Create方法：根据宽高添加

  1. #pragma once
  2. namespace YOTO {
  3. 	class Texture
  4. 	{
  5. 	public:
  6. 		virtual ~Texture() = default;
  7. 		virtual uint32_t GetWidth()const = 0;
  8. 		virtual uint32_t GetHeight()const = 0;
  9. 		virtual void SetData(void* data, uint32_t size) = 0;
  10. 		virtual void Bind(uint32_t slot=0)const = 0;
  11.  
  12. 	};
  13. 	class Texture2D :public Texture 
  14. 	{
  15. 	public:
  16. 		static Ref<Texture2D>Create(uint32_t width,uint32_t height);
  17. 		static Ref<Texture2D>Create(const std::string& path);
  18. 	};
  19. }
  20.  
  21.

Texture.cpp： 

  1. #include "ytpch.h"
  2. #include "Texture.h"
  3. #include"Renderer.h"
  4. #include "Platform/OpenGL/OpenGLTexture.h"
  5. namespace YOTO {
  6. 	Ref<Texture2D> Texture2D::Create(uint32_t width, uint32_t height)
  7. 	{
  8. 		switch (Renderer::GetAPI())
  9. 		{
  10. 		case RendererAPI::API::None:
  11. 			YT_CORE_ASSERT(false, "Texture2D：API为None不支持");
  12. 			return nullptr;
  13. 		case RendererAPI::API::OpenGL:
  14. 			return  CreateRef<OpenGLTexture2D>(width,height);
  15. 		}
  16. 		YT_CORE_ASSERT(false, "Buffer：未知API");
  17. 		return nullptr;
  18. 	}
  19. 	Ref<Texture2D> Texture2D::Create(const std::string& path)
  20. 	{
  21. 		switch (Renderer::GetAPI())
  22. 		{
  23. 		case RendererAPI::API::None:
  24. 			YT_CORE_ASSERT(false, "Texture2D：API为None不支持");
  25. 			return nullptr;
  26. 		case RendererAPI::API::OpenGL:
  27. 			return  CreateRef<OpenGLTexture2D>(path);
  28. 		}
  29. 		YT_CORE_ASSERT(false, "Buffer：未知API");
  30. 		return nullptr;
  31. 	}
  32. }

OpenGLTexture.h:同Texture.h相同，且添加设置texture数据的方法SetData:

  1. #pragma once
  2. #include"YOTO/Renderer/Texture.h"
  3. #include<glad/glad.h>
  4. namespace YOTO {
  5. 	class OpenGLTexture2D:public Texture2D
  6. 	{
  7. 	public:
  8. 		OpenGLTexture2D(uint32_t width,uint32_t height);
  9. 		OpenGLTexture2D(const std::string path);
  10. 		virtual~OpenGLTexture2D();
  11. 		virtual uint32_t GetWidth()const override { return m_Width; }
  12. 		virtual uint32_t GetHeight()const override { return m_Height; }
  13. 	
  14. 		virtual void SetData(void* data, uint32_t size)override;
  15.  
  16. 		virtual void Bind(uint32_t slot=0)const override;
  17. 	private:
  18. 		std::string m_Path;
  19. 		uint32_t m_Width, m_Height;
  20. 		uint32_t m_RendererID;
  21. 		GLenum m_InternalFormat, m_DataFormat;
  22. 	};
  23. }
  24.  
  25.

OpenGLTexture.cpp: 

  1. #include "ytpch.h"
  2. #include "OpenGLTexture.h"
  3. #include<glad/glad.h>
  4. #include"stb_image.h"
  5. namespace YOTO {
  6. 	OpenGLTexture2D::OpenGLTexture2D(uint32_t width, uint32_t height)
  7. 		:m_Width(width),m_Height(height)
  8. 	{
  9. 		m_InternalFormat = GL_RGBA8;
  10. 		m_DataFormat = GL_RGBA;
  11. 		
  12. 	
  13. 			glCreateTextures(GL_TEXTURE_2D, 1, &m_RendererID);
  14. 		///告诉OpenGLm_RendererID的纹理存储的是rbg8位，宽高的缓冲区
  15. 		glTextureStorage2D(m_RendererID, 1, m_InternalFormat, m_Width, m_Height);
  16. 		//配置参数:纹理放大时用周围颜色的平均值过滤
  17. 		glTextureParameteri(m_RendererID, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
  18. 		glTextureParameteri(m_RendererID, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  19.  
  20. 		glTextureParameteri(m_RendererID, GL_TEXTURE_WRAP_S, GL_REPEAT);
  21. 		glTextureParameteri(m_RendererID, GL_TEXTURE_WRAP_T, GL_REPEAT);
  22.  
  23. 	
  24. 	}
  25. 	OpenGLTexture2D::OpenGLTexture2D(const std::string path)
  26. 		:m_Path(path)
  27. 	{
  28. 		int width, height, channels;
  29. 		stbi_set_flip_vertically_on_load(1);//翻转
  30. 		stbi_uc*data=stbi_load(path.c_str(),&width,&height,&channels,0);
  31. 		YT_CORE_ASSERT(data, "图片加载错误");
  32. 		m_Width = width;
  33. 		m_Height = height;
  34.  
  35. 		GLenum internalFormat = 0,dataFormat=0;
  36. 		if (channels == 4) {
  37. 			internalFormat = GL_RGBA8;
  38. 			dataFormat = GL_RGBA;
  39. 		}
  40. 		else if (channels==3) {
  41. 			internalFormat = GL_RGB8;
  42. 			dataFormat = GL_RGB;
  43. 		}
  44.  
  45. 		m_InternalFormat = internalFormat;
  46. 		m_DataFormat = dataFormat;
  47.  
  48. 		YT_CORE_ASSERT(internalFormat& dataFormat,"OpenGLTexture2D：不支持的颜色格式")
  49. 		//创建纹理
  50. 		glCreateTextures(GL_TEXTURE_2D, 1, &m_RendererID);
  51. 		///告诉OpenGLm_RendererID的纹理存储的是rbg8位，宽高的缓冲区
  52. 		glTextureStorage2D(m_RendererID, 1, internalFormat,m_Width,m_Height);
  53. 		//配置参数:纹理放大时用周围颜色的平均值过滤
  54. 		glTextureParameteri(m_RendererID,GL_TEXTURE_MIN_FILTER,GL_LINEAR);
  55. 		glTextureParameteri(m_RendererID, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
  56.  
  57. 		glTextureParameteri(m_RendererID, GL_TEXTURE_WRAP_S, GL_REPEAT);
  58. 		glTextureParameteri(m_RendererID, GL_TEXTURE_WRAP_T, GL_REPEAT);
  59.  
  60. 		glTextureSubImage2D(m_RendererID, 0, 0, 0, m_Width, m_Height, dataFormat,GL_UNSIGNED_BYTE,data);
  61. 		stbi_image_free(data);
  62. 	}
  63. 	OpenGLTexture2D::~OpenGLTexture2D()
  64. 	{
  65. 		glDeleteTextures(1,&m_RendererID);
  66. 	}
  67. 	void OpenGLTexture2D::SetData(void* data, uint32_t size)
  68. 	{
  69. 		uint32_t bpc = m_DataFormat == GL_RGBA ? 4 : 3;
  70. 		YT_CORE_ASSERT(size == m_Width * m_Height * bpc,"OpenGLTexture2D：数据必须是完整的！");
  71. 		glTextureSubImage2D(m_RendererID, 0, 0, 0, m_Width, m_Height,m_DataFormat, GL_UNSIGNED_BYTE,data);
  72. 	}
  73. 	void OpenGLTexture2D::Bind(uint32_t slot) const
  74. 	{
  75. 		glBindTextureUnit(slot, m_RendererID);
  76. 	}
  77. }

Sandbox2D.h:添加m_CheckerboardTexture

  1. #pragma once
  2. #include "YOTO.h"
  3. class Sandbox2D :public YOTO::Layer
  4. {public:
  5. 	Sandbox2D();
  6. 	virtual ~Sandbox2D() = default;
  7. 	virtual void OnAttach()override;
  8. 	virtual void OnDetach()override;
  9.  
  10. 	void OnUpdate(YOTO::Timestep ts)override;
  11. 	virtual void OnImGuiRender() override;
  12. 	void OnEvent(YOTO::Event& e)override;
  13. private:
  14. 	YOTO::OrthographicCameraController m_CameraController;
  15.  
  16. 	YOTO::Ref<YOTO::Shader> m_FlatColorShader;
  17. 	YOTO::Ref<YOTO::VertexArray> m_SquareVA;
  18. 	YOTO::Ref<YOTO::Texture2D>m_CheckerboardTexture;
  19. 	glm::vec4 m_SquareColor = { 0.2f,0.3f,0.7f,1.0f };
  20. };
  21.

化简Sandbox2D：

Sandbox2D.cpp:把传shader参数的代码注释掉 ，统一使用DrawQuad封装；负责“怎么画”的问题：

  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. Sandbox2D::Sandbox2D()
  7. :Layer("Sandbox2D"), m_CameraController(1280.0f / 720.0f, true) 
  8. {
  9. }
  10. void Sandbox2D::OnAttach()
  11. {
  12. 	m_CheckerboardTexture = YOTO::Texture2D::Create("assets/textures/Checkerboard.png");
  13.  
  14. }
  15. void Sandbox2D::OnDetach()
  16. {
  17. }
  18.  
  19. void Sandbox2D::OnUpdate(YOTO::Timestep ts)
  20. {	//update
  21. 	m_CameraController.OnUpdate(ts);
  22.  
  23. 	//Render
  24. 	YOTO::RenderCommand::SetClearColor({ 0.2f, 0.2f, 0.2f, 1.0f });
  25. 	YOTO::RenderCommand::Clear();
  26.  
  27. 	YOTO::Renderer2D::BeginScene(m_CameraController.GetCamera());
  28. 	{
  29. 		static glm::mat4 scale = glm::scale(glm::mat4(1.0f), glm::vec3(0.1f));
  30. 		glm::vec4  redColor(0.8f, 0.3f, 0.3f, 1.0f);
  31. 		glm::vec4  blueColor(0.2f, 0.3f, 0.8f, 1.0f);
  32.  
  33.  
  34. 		/*std::dynamic_pointer_cast<YOTO::OpenGLShader>(m_FlatColorShader)->Bind();
  35. 		std::dynamic_pointer_cast<YOTO::OpenGLShader>(m_FlatColorShader)->UploadUniformFloat4("u_Color", m_SquareColor);
  36. 		YOTO::Renderer::Submit(m_FlatColorShader, m_SquareVA, glm::scale(glm::mat4(1.0f), glm::vec3(1.5f)));*/
  37.  
  38. 		YOTO::Renderer2D::DrawQuad({ -1.0f,0.0f }, { 0.8f,0.8f }, {0.8f,0.2f,0.3f,1.0f});
  39. 		YOTO::Renderer2D::DrawQuad({ 0.5f,-0.5f }, { 0.5f,0.75f }, { 0.2f,0.3f,0.8f,1.0f });
  40. 		YOTO::Renderer2D::DrawQuad({ 0.0f,0.0f,-0.1f }, {10.0f,10.0f }, m_CheckerboardTexture);
  41. 		YOTO::Renderer2D::EndScene();
  42. 	}
  43. }
  44. void Sandbox2D::OnImGuiRender()
  45. {
  46. 	ImGui::Begin("设置");
  47. 	ImGui::ColorEdit4("正方形颜色", glm::value_ptr(m_SquareColor));
  48. 	ImGui::End();
  49. }
  50.  
  51. void Sandbox2D::OnEvent(YOTO::Event& e)
  52. {
  53. 	m_CameraController.OnEvent(e);
  54. }

小修改：

OpenGLRendererAPI.cpp:DrawIndexed中添加解绑Texture：

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

flatColor.glsl:

  1. 		#type vertex
  2. 		#version 330 core
  3. 		layout(location = 0) in vec3 a_Position;
  4.  
  5. 		uniform mat4 u_ViewProjection;
  6. 		uniform mat4 u_Transform;
  7. 		
  8.  
  9.  
  10. 		void main(){
  11. 		gl_Position =u_ViewProjection*u_Transform*vec4( a_Position,1.0);
  12. 		}
  13.  
  14. 		#type fragment
  15. 		#version 330 core
  16. 		layout(location = 0) out vec4 color;
  17. 	
  18. 		uniform vec4 u_Color ;
  19. 		void main(){
  20. 		color =u_Color;	
  21. 		}

Texture.glsl:

  1. 		#type vertex
  2. 		#version 330 core
  3. 		layout(location = 0) in vec3 a_Position;
  4. 		layout(location = 1) in vec2 a_TexCoord;
  5.  
  6. 		uniform mat4 u_ViewProjection;
  7. 		uniform mat4 u_Transform;
  8. 		
  9. 		out vec2 v_TexCoord;
  10. 		out vec3 v_Position;
  11.  
  12. 		void main(){
  13. 		v_TexCoord=a_TexCoord;
  14. 		v_Position=a_Position;
  15. 		gl_Position =u_ViewProjection*u_Transform*vec4( a_Position,1.0);
  16. 		}
  17.  
  18. 		#type fragment
  19. 		#version 330 core
  20. 		layout(location = 0) out vec4 color;
  21. 		in vec3 v_Position;
  22. 	
  23. 		in vec2 v_TexCoord;
  24.  
  25. 		uniform vec4 u_Color ;
  26. 		uniform sampler2D u_Texture ;
  27. 		void main(){
  28. 		color = texture(u_Texture, v_TexCoord*10.0f)*u_Color;	
  29. 		}

YOTO.h:添加：

#include"YOTO/Renderer/Renderer2D.h"

Core.h:

  1. #pragma once
  2. #include<memory>
  3. //用于dll的宏
  4. #ifdef YT_PLATFORM_WINDOWS
  5. #if YT_DYNAMIC_LINK
  6. 		#ifdef YT_BUILD_DLL
  7. 		#define YOTO_API __declspec(dllexport) 
  8. 		#else
  9. 		#define YOTO_API __declspec(dllimport) 
  10.  
  11. 		#endif // DEBUG
  12. #else
  13. 		#define YOTO_API
  14. #endif
  15. #else
  16. #error YOTO_ONLY_SUPPORT_WINDOWS
  17. #endif // YOTO_PLATFORM_WINDOWS
  18.  
  19. #ifdef YT_DEBUG
  20. #define YT_ENABLE_ASSERTS
  21. #endif
  22.  
  23. #ifdef YT_ENABLE_ASSERTS
  24. #define YT_CLIENT_ASSERT(x,...) {if(!(x)){YT_CLIENT_ERROR("断言错误：{0}",__VA_ARGS__);__debugbreak();}}
  25. #define YT_CORE_ASSERT(x,...) {if(!(x)){YT_CORE_ERROR("断言错误：{0}",__VA_ARGS__);__debugbreak();}}
  26. #else
  27. #define YT_CLIENT_ASSERT(x,...)
  28. #define YT_CORE_ASSERT(x,...)
  29.  
  30. #endif // YT_ENABLE_ASSERTS
  31.  
  32.  
  33.  
  34. #define BIT(x)(1<<x)
  35. //绑定事件定义
  36. #define YT_BIND_EVENT_FN(fn) std::bind(&fn, this, std::placeholders::_1)
  37.  
  38. namespace YOTO {
  39. 	template<typename T>
  40. 	using  Scope = std::unique_ptr<T>;
  41. 	template<typename T>
  42. 	using  Ref = std::shared_ptr<T>;
  43.  
  44. 	template<typename T,typename ...Args>
  45. 	constexpr Scope<T> CreateScope(Args&&...args) {
  46. 		return std::make_shared<T>(std::forward<Args>(args)...);
  47. 	}
  48. 	template<typename T, typename ...Args>
  49. 	constexpr Ref<T> CreateRef(Args&&...args) {
  50. 		return std::make_shared<T>(std::forward<Args>(args)...);
  51. 	}
  52.  
  53. }

测试：

cool！ 

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

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

  

闽ICP备14008679号