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

    封装2DRenderer：

    Renderer.h:

    1. #include"ytpch.h"
    2. #include"Renderer.h"
    3. #include 
    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, const Ref& vertexArray, const glm::mat4& transform)
    24. 	{
    25. 		shader->Bind();
    26. 		std::dynamic_pointer_cast(shader)->UploadUniformMat4("u_ViewProjection", m_SceneData->ViewProjectionMatrix);
    27. 		std::dynamic_pointer_cast(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 texture);
    16. 		static void DrawQuad(const glm::vec3& position, const glm::vec2& size, const Ref 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 
    7. #include "RenderCommand.h"
    8. namespace YOTO {
    9. 	struct  Renderer2DStorage {
    10. 		Ref QuadVertexArray;
    11. 		//Ref FlatColorShader;
    12. 		Ref TextureShader;
    13. 		Ref 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 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 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 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 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 
    3. #include
    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 Create(const std::string& filepath);
    21. 		static Ref 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);
    27. 		void Add(const std::string &name,const Ref& shader);
    28. 		Ref Load(const std::string filepath);
    29. 		Ref Load(const std::string &name,const std::string filepath);
    30. 		Ref Get(const std::string& name);
    31. 		bool Exists(const std::string& name);
    32. 	private:
    33. 		std::unordered_map> m_Shaders;
    34.  
    35. 	};
    36. }

    OpenGLShader.h:同Shader.h

    1. #pragma once
    2. #include 
    3. #include "YOTO/Renderer/Shader.h"
    4. #include 
    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 PreProcess(const std::string& source);
    35. 		void Compile(const std::unordered_map& 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 
    5. #include
    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_mapsources;
    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 OpenGLShader::PreProcess(const std::string& source)
    60. 	{
    61. 		std::unordered_map 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& shaderSources)
    94. 	{
    95. 		GLuint program = glCreateProgram();
    96. 		YT_CORE_ASSERT(shaderSources.size()<=2,"OpenGLShader：shader只支持两种！")
    97. 		std::arrayglShaderIDs;
    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 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 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 RefCreate(uint32_t width,uint32_t height);
    17. 		static RefCreate(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::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(width,height);
    15. 		}
    16. 		YT_CORE_ASSERT(false, "Buffer：未知API");
    17. 		return nullptr;
    18. 	}
    19. 	Ref 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(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
    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
    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 m_FlatColorShader;
    17. 	YOTO::Ref m_SquareVA;
    18. 	YOTO::Refm_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 
    3. #include 
    4. //#include 
    5. #include 
    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(m_FlatColorShader)->Bind();
    35. 		std::dynamic_pointer_cast(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 
    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)
    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
    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<
    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;
    41. 	template<typename T>
    42. 	using  Ref = std::shared_ptr;
    43.  
    44. 	template<typename T,typename ...Args>
    45. 	constexpr Scope CreateScope(Args&&...args) {
    46. 		return std::make_shared(std::forward(args)...);
    47. 	}
    48. 	template<typename T, typename ...Args>
    49. 	constexpr Ref CreateRef(Args&&...args) {
    50. 		return std::make_shared(std::forward(args)...);
    51. 	}
    52.  
    53. }

    测试：

    cool！ 

  • 相关阅读:
    golang八股文整理（持续搬运）
    .netCore .net5,6,7 存日志文件
    MNE绘制自定义通道位置及名字的脑地形图
    【图文并茂】 做开发这么久了，还不会搭建服务器Maven私有仓库？这也太Low了吧
    系统学习Shell之正则表达式
    Scrum敏捷开发：适应变化的核心能力
    EChart常见配置项解析
    1分钟精准预测未来10天天气，谷歌开源GraphCast
    漫画 | 30年后，中国就会有自己的编程语言！
    vue 父组件给子组件传递一个函数，子组件调用父组件中的方法
  • 原文地址：https://blog.csdn.net/weixin_61943345/article/details/136233386