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

跟着cherno手搓游戏引擎【21】shaderLibrary（shader管理类）

作者：weixin_40725706 | 2024-02-15 19:47:48

赞

踩

跟着cherno手搓游戏引擎【21】shaderLibrary（shader管理类）

前置：

ytpch.h：

  1. #pragma once
  2. #include<iostream>
  3. #include<memory>
  4. #include<utility>
  5. #include<algorithm>
  6. #include<functional>
  7. #include<string>
  8. #include<vector>
  9. #include<unordered_map>
  10. #include<unordered_set>
  11. #include<sstream>
  12. #include<array>
  13. #ifdef YT_PLATFORM_WINDOWS
  14. #include<Windows.h>
  15. #endif // YT_PLATFORM_WINDOWS
  16.  
  17.

创建glsl文件：

 

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. 		in vec2 v_TexCoord;
  23. 		uniform sampler2D u_Texture ;
  24. 		void main(){
  25. 		color = texture(u_Texture, v_TexCoord);	
  26. 		}

抽象：

Shader.h:

  1. #pragma once
  2. #include <string>
  3. #include"YOTO/Core.h"
  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 const std::string& GetName()const = 0;
  14.  
  15. 		static Ref<Shader> Create(const std::string& filepath);
  16. 		static Ref<Shader> Create(const std::string&name, const std::string& vertexSrc, const std::string& fragmentSrc);
  17.  
  18. 	};
  19. 	class ShaderLibrary {
  20. 	public:
  21. 		void Add(const Ref<Shader>& shader);
  22. 		void Add(const std::string &name,const Ref<Shader>& shader);
  23. 		Ref<Shader> Load(const std::string filepath);
  24. 		Ref<Shader> Load(const std::string &name,const std::string filepath);
  25. 		Ref<Shader> Get(const std::string& name);
  26. 		bool Exists(const std::string& name);
  27. 	private:
  28. 		std::unordered_map<std::string,Ref<Shader>> m_Shaders;
  29.  
  30. 	};
  31. }

Shader.cpp:

  1. #include "ytpch.h"
  2. #include "Shader.h"
  3. #include"Renderer.h"
  4. #include "Platform/OpenGL/OpenGLShader.h"
  5. namespace YOTO {
  6. 	Ref<Shader> Shader::Create(const std::string& filepath)
  7. 	{
  8. 		switch (Renderer::GetAPI())
  9. 		{
  10. 		case RendererAPI::API::None:
  11. 			YT_CORE_ASSERT(false, "Shader：API为None不支持");
  12. 			return nullptr;
  13. 		case RendererAPI::API::OpenGL:
  14. 			return std::make_shared <OpenGLShader>(filepath);
  15. 		}
  16. 		YT_CORE_ASSERT(false, "Buffer：未知API");
  17. 		return nullptr;
  18. 	}
  19. 	Ref<Shader> Shader::Create(const std::string& name, const std::string& vertexSrc, const std::string& fragmentSrc)
  20. 	{
  21. 		switch (Renderer::GetAPI())
  22. 		{
  23. 		case RendererAPI::API::None:
  24. 			YT_CORE_ASSERT(false, "Shader：API为None不支持");
  25. 			return nullptr;
  26. 		case RendererAPI::API::OpenGL:
  27. 			return std::make_shared <OpenGLShader>(name,vertexSrc, fragmentSrc);
  28. 		}
  29. 		YT_CORE_ASSERT(false, "Buffer：未知API");
  30. 		return nullptr;
  31. 	}
  32. 	void ShaderLibrary::Add(const Ref<Shader>& shader)
  33. 	{
  34. 		auto& name = shader->GetName();
  35. 		Add(name, shader);
  36. 	}
  37. 	void ShaderLibrary::Add(const std::string& name, const Ref<Shader>& shader)
  38. 	{
  39. 	
  40. 		YT_CORE_ASSERT(!Exists(name), "ShaderLibrary:shader已经存在了")
  41. 			m_Shaders[name] = shader;
  42. 	}
  43. 	Ref<Shader> ShaderLibrary::Load(const std::string filepath)
  44. 	{
  45. 		auto shader = Shader::Create(filepath);
  46. 		Add(shader);
  47. 		return shader;
  48. 	}
  49. 	Ref<Shader> ShaderLibrary::Load(const std::string& name, const std::string filepath)
  50. 	{
  51. 		auto shader = Shader::Create(filepath);
  52. 		Add(shader);
  53. 		return shader;
  54. 	}
  55. 	Ref<Shader> ShaderLibrary::Get(const std::string& name)
  56. 	{YT_CORE_ASSERT(Exists(name),"ShaderLibrary:未找到shader")
  57. 		return m_Shaders[name];
  58. 	}
  59. 	bool ShaderLibrary::Exists(const std::string& name)
  60. 	{
  61. 		return m_Shaders.find(name)!=m_Shaders.end();
  62. 	}
  63. }

实现：

OpenGLShader.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. 		virtual const std::string& GetName()const override { return m_Name; }
  17. 		void UploadUniformMat4(const std::string& name, const glm::mat4& matrix);
  18. 		void UploadUniformMat3(const std::string& name, const glm::mat3& matrix);
  19.  
  20. 		void UploadUniformFloat4(const std::string& name, const glm::vec4& values);
  21. 		void UploadUniformFloat3(const std::string& name, const glm::vec3& values);
  22. 		void UploadUniformFloat2(const std::string& name, const glm::vec2& values);
  23. 		void UploadUniformFloat(const std::string& name, float values);
  24.  
  25. 		void UploadUniformInt(const std::string& name, int values);
  26. 	private:
  27. 		std::string ReadFile(const std::string filepath);
  28. 		std::unordered_map<GLenum,std::string> PreProcess(const std::string& source);
  29. 		void Compile(const std::unordered_map<GLenum, std::string>& shaderSources);
  30. 	private:
  31. 		uint32_t m_RendererID;
  32. 		std::string m_Name;
  33. 	}
  34. 	;
  35. }

OpenGLShader.cpp:

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

调用：

SandboxApp.cpp:

  1. #include<YOTO.h>
  2. #include "imgui/imgui.h"
  3. #include<stdio.h>
  4. #include <glm/gtc/matrix_transform.hpp>
  5. #include <Platform/OpenGL/OpenGLShader.h>
  6. #include <glm/gtc/type_ptr.hpp>
  7.  
  8. class ExampleLayer:public YOTO::Layer
  9. {
  10. public:
  11. 	ExampleLayer()
  12. 	:Layer("Example"),  m_Camera(-2.0f, 2.0f, -2.0f, 2.0f), m_CameraPosition(0){
  13. 		uint32_t indices[3] = { 0,1,2 };
  14. 		float vertices[3 * 7] = {
  15. 			-0.5f,-0.5f,0.0f, 0.8f,0.2f,0.8f,1.0f,
  16. 			0.5f,-0.5f,0.0f,  0.2f,0.3f,0.8f,1.0f,
  17. 			0.0f,0.5f,0.0f,   0.8f,0.8f,0.2f,1.0f,
  18. 		};
  19.  
  20. 		m_VertexArray.reset(YOTO::VertexArray::Create());
  21.  
  22.  
  23. 		YOTO::Ref<YOTO::VertexBuffer> m_VertexBuffer;
  24. 		m_VertexBuffer.reset(YOTO::VertexBuffer::Create(vertices, sizeof(vertices)));
  25.  
  26. 		{
  27. 			YOTO::BufferLayout setlayout = {
  28.  
  29. 	{YOTO::ShaderDataType::Float3,"a_Position"},
  30. 		{YOTO::ShaderDataType::Float4,"a_Color"}
  31. 			};
  32. 			m_VertexBuffer->SetLayout(setlayout);
  33.  
  34. 		}
  35.  
  36. 		m_VertexArray->AddVertexBuffer(m_VertexBuffer);
  37.  
  38.  
  39. 		YOTO::Ref<YOTO::IndexBuffer>m_IndexBuffer;
  40. 		m_IndexBuffer.reset(YOTO::IndexBuffer::Create(indices, sizeof(indices) / sizeof(uint32_t)));
  41.  
  42. 		m_VertexArray->AddIndexBuffer(m_IndexBuffer);
  43.  
  44. 		std::string vertexSource = R"(
  45. 		#version 330 core
  46. 		layout(location = 0) in vec3 a_Position;
  47. 		layout(location = 1) in vec4 a_Color;
  48. 		uniform mat4 u_ViewProjection;
  49. 		uniform mat4 u_Transform;
  50. 		out vec3 v_Position;
  51. 		out vec4 v_Color;
  52. 		void main(){
  53. 		v_Position=a_Position;
  54. 		v_Color=a_Color;
  55. 		gl_Position =u_ViewProjection *u_Transform* vec4( a_Position,1.0);
  56. 		}
  57. 		)";
  58. 		//绘制颜色
  59. 		std::string fragmentSource = R"(
  60. 		#version 330 core
  61. 		layout(location = 0) out vec4 color;
  62. 		in vec3 v_Position;
  63. 		in vec4 v_Color;
  64. 		void main(){
  65. 		color=vec4(v_Color);
  66. 		}
  67. 		)";
  68. 		m_Shader=(YOTO::Shader::Create("VertexPosColor", vertexSource, fragmentSource));
  69.  
  70. 		///测试/
  71.  
  72. 		m_SquareVA.reset(YOTO::VertexArray::Create());
  73.  
  74. 		float squareVertices[5 * 4] = {
  75. 			-0.5f,-0.5f,0.0f, 0.0f,0.0f,
  76. 			0.5f,-0.5f,0.0f,  1.0f,0.0f,
  77. 			0.5f,0.5f,0.0f,   1.0f,1.0f,
  78. 			-0.5f,0.5f,0.0f,  0.0f,1.0f,
  79. 		};
  80. 		YOTO::Ref<YOTO::VertexBuffer> squareVB;
  81. 		squareVB.reset(YOTO::VertexBuffer::Create(squareVertices, sizeof(squareVertices)));
  82. 		squareVB->SetLayout({
  83. 			{YOTO::ShaderDataType::Float3,"a_Position"},
  84. 				{YOTO::ShaderDataType::Float2,"a_TexCoord"}
  85. 			});
  86. 		m_SquareVA->AddVertexBuffer(squareVB);
  87. 		uint32_t squareIndices[6] = { 0,1,2,2,3,0 };
  88. 		YOTO::Ref<YOTO::IndexBuffer> squareIB;
  89.  
  90. 		squareIB.reset((YOTO::IndexBuffer::Create(squareIndices, sizeof(squareIndices) / sizeof(uint32_t))));
  91.  
  92. 		m_SquareVA->AddIndexBuffer(squareIB);
  93.  
  94. 		//测试：
  95. 		std::string BlueShaderVertexSource = R"(
  96. 		#version 330 core
  97. 		layout(location = 0) in vec3 a_Position;
  98. 		uniform mat4 u_ViewProjection;
  99. 		uniform mat4 u_Transform;
  101. 		out vec3 v_Position;
  102. 		void main(){
  103. 		v_Position=a_Position;
  104. 		gl_Position =u_ViewProjection*u_Transform*vec4( a_Position,1.0);
  105. 		}
  106. 		)";
  107. 		//绘制颜色
  108. 		std::string BlueShaderFragmentSource = R"(
  109. 		#version 330 core
  110. 		layout(location = 0) out vec4 color;
  112. 		in vec3 v_Position;
  113. 		uniform vec3 u_Color;
  114. 		void main(){
  115. 		color=vec4(u_Color,1.0);
  116. 		}
  117. 		)";
  118. 		m_BlueShader=(YOTO::Shader::Create("FlatColor", BlueShaderVertexSource, BlueShaderFragmentSource));
  119.  
  120. 	auto textureShader=	m_ShaderLibrary.Load("assets/shaders/Texture.glsl");
  121. 		m_Texture=YOTO::Texture2D::Create("assets/textures/Checkerboard.png");
  122. 		m_ChernoLogo= YOTO::Texture2D::Create("assets/textures/ChernoLogo.png");
  123. 		std::dynamic_pointer_cast<YOTO::OpenGLShader>(textureShader)->Bind();
  124. 		std::dynamic_pointer_cast<YOTO::OpenGLShader>(textureShader)->UploadUniformInt("u_Texture", 0);
  125. 	}
  126. 	void OnImGuiRender() override {
  127. 		ImGui::Begin("设置");
  128. 		ImGui::ColorEdit3("正方形颜色", glm::value_ptr(m_SquareColor));
  129. 		ImGui::End();
  130. 	}
  131. 	void OnUpdate(YOTO::Timestep ts)override {
  132. 		//YT_CLIENT_TRACE("delta time {0}s ({1}ms)", ts.GetSeconds(), ts.GetMilliseconds());
  133. 	
  134.  
  135. 		if (YOTO::Input::IsKeyPressed(YT_KEY_LEFT)) {
  136. 			m_CameraPosition.x -= m_CameraMoveSpeed* ts;
  137. 		}
  138. 		else if (YOTO::Input::IsKeyPressed(YT_KEY_RIGHT)) {
  139. 			m_CameraPosition.x += m_CameraMoveSpeed * ts;
  140. 		}
  141. 		if (YOTO::Input::IsKeyPressed(YT_KEY_DOWN)) {
  142. 			m_CameraPosition.y -= m_CameraMoveSpeed * ts;
  143. 		}
  144. 		else if (YOTO::Input::IsKeyPressed(YT_KEY_UP)) {
  145. 			m_CameraPosition.y += m_CameraMoveSpeed * ts;
  146. 		}
  147. 		if (YOTO::Input::IsKeyPressed(YT_KEY_A)) {
  148. 			m_CameraRotation += m_CameraRotationSpeed * ts;
  149. 		}else if (YOTO::Input::IsKeyPressed(YT_KEY_D)) {
  150. 			m_CameraRotation -= m_CameraRotationSpeed * ts;
  151. 		}
  152.  
  153. 		YOTO::RenderCommand::SetClearColor({ 0.2f, 0.2f, 0.2f, 1.0f });
  154. 		YOTO::RenderCommand::Clear();
  155. 		m_Camera.SetPosition(m_CameraPosition);
  156. 		m_Camera.SetRotation(m_CameraRotation);
  157. 		YOTO::Renderer::BeginScene(m_Camera);
  158. 		{
  159. 			static glm::mat4 scale = glm::scale(glm::mat4(1.0f), glm::vec3(0.1f)); 
  160. 			glm::vec4  redColor(0.8f, 0.3f, 0.3f, 1.0f);
  161. 			glm::vec4  blueColor(0.2f, 0.3f, 0.8f, 1.0f);
  162.  
  163. 	/*		YOTO::MaterialRef material = new YOTO::MaterialRef(m_FlatColorShader);
  164. 			YOTO::MaterialInstaceRef mi = new YOTO::MaterialInstaceRef(material);
  165. 			mi.setValue("u_Color",redColor);
  166. 			mi.setTexture("u_AlbedoMap", texture);
  167. 			squreMesh->SetMaterial(mi);*/
  168.  
  169. 			std::dynamic_pointer_cast<YOTO::OpenGLShader>(m_BlueShader)->Bind();
  170. 			std::dynamic_pointer_cast<YOTO::OpenGLShader>(m_BlueShader)->UploadUniformFloat3("u_Color",m_SquareColor);
  171. 			for (int y = 0; y < 20; y++) {
  172. 				for (int x = 0; x <20; x++)
  173. 				{
  174.  
  175. 					glm::vec3 pos(x * 0.105f,y* 0.105f, 0.0);
  176. 					glm::mat4 transform = glm::translate(glm::mat4(1.0f), pos) * scale;
  177. 					/*if (x % 2 == 0) {
  178. 						m_BlueShader->UploadUniformFloat4("u_Color", redColor);
  179. 					}
  180. 					else {
  181. 						m_BlueShader->UploadUniformFloat4("u_Color", blueColor);
  182. 					}*/
  183. 		
  184.  
  185. 					YOTO::Renderer::Submit(m_BlueShader, m_SquareVA, transform);
  186. 				}
  187. 			}
  188. 			
  189. 			auto textureShader = m_ShaderLibrary.Get("Texture");
  190. 			m_Texture->Bind();
  191. 			YOTO::Renderer::Submit(textureShader, m_SquareVA, glm::scale(glm::mat4(1.0f), glm::vec3(1.5f)));
  192. 			m_ChernoLogo->Bind();
  193. 			YOTO::Renderer::Submit(textureShader, m_SquareVA, glm::scale(glm::mat4(1.0f), glm::vec3(1.5f)));
  194.  
  195. 			//YOTO::Renderer::Submit(m_Shader, m_VertexArray);
  196.  
  197.  
  198. 			YOTO::Renderer::EndScene();
  199. 		}
  200.  
  201. 	}
  202. 	void OnEvent(YOTO::Event& event)override {
  203. 		/*if (event.GetEventType() == YOTO::EventType::KeyPressed) {
  204. 		YOTO:: KeyPressedEvent& e = (YOTO::KeyPressedEvent&)event;
  205. 		YT_CLIENT_TRACE("ExampleLayer:{0}",(char)e.GetKeyCode());
  206. 		if (e.GetKeyCode()==YT_KEY_TAB) {
  207. 			YT_CLIENT_INFO("ExampleLayerOnEvent:TAB按下了");
  208. 		}}*/
  209. 		//YT_CLIENT_TRACE("SandBoxApp:测试event{0}", event);
  210.  
  211.  
  212.  
  213.  
  214. 	}
  215.  
  216.  
  217. private:
  218. 	YOTO::ShaderLibrary m_ShaderLibrary;
  219. 	YOTO::Ref<YOTO::Shader> m_Shader;
  220. 	YOTO::Ref<YOTO::VertexArray> m_VertexArray;
  221.  
  222.  
  223. 	YOTO::Ref<YOTO::Shader> m_BlueShader;
  224. 	YOTO::Ref<YOTO::VertexArray> m_SquareVA;
  225. 	
  226. 	YOTO::Ref<YOTO::Texture2D> m_Texture,m_ChernoLogo;
  227.  
  228. 	YOTO::OrthographicCamera m_Camera;
  229. 	glm::vec3 m_CameraPosition;
  230. 	float m_CameraMoveSpeed = 5.0f;
  231.  
  232. 	float m_CameraRotation = 0;
  233. 	float m_CameraRotationSpeed = 180.0f;
  234.  
  235. 	glm::vec3 m_SquareColor = { 0.2f,0.3f,0.7f };
  236.  
  237. };
  238.  
  239.  
  240. class Sandbox:public YOTO::Application
  241. {
  242. public:
  243. 	Sandbox(){
  244. 		PushLayer(new ExampleLayer());
  245. 		//PushLayer(new YOTO::ImGuiLayer());
  246. 	}
  247. 	~Sandbox() {
  248.  
  249. 	}
  250.  
  251. private:
  252.  
  253. };
  254.  
  255. YOTO::Application* YOTO::CreateApplication() {
  256. 	printf("helloworld");
  257. 	return new Sandbox();
  258. }

测试：

cool！ 

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

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

  

闽ICP备14008679号