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

跟着cherno手搓游戏引擎【22】CameraController、Resize

作者：小小林熬夜学编程 | 2024-02-15 09:17:54

赞

踩

跟着cherno手搓游戏引擎【22】CameraController、Resize

前置：

YOTO.h: 

  1. #pragma once
  2.  
  3. //用于YOTO APP
  4.  
  5. #include "YOTO/Application.h"
  6. #include"YOTO/Layer.h"
  7. #include "YOTO/Log.h"
  8.  
  9. #include"YOTO/Core/Timestep.h"
  10.  
  11. #include"YOTO/Input.h"
  12. #include"YOTO/KeyCode.h"
  13. #include"YOTO/MouseButtonCodes.h"
  14. #include "YOTO/OrthographicCameraController.h"
  15.  
  16. #include"YOTO/ImGui/ImGuiLayer.h"
  17.  
  18. //Renderer
  19. #include"YOTO/Renderer/Renderer.h"
  20. #include"YOTO/Renderer/RenderCommand.h"
  21.  
  22. #include"YOTO/Renderer/Buffer.h"
  23. #include"YOTO/Renderer/Shader.h"
  24. #include"YOTO/Renderer/Texture.h"
  25. #include"YOTO/Renderer/VertexArray.h"
  26.  
  27. #include"YOTO/Renderer/OrthographicCamera.h"
  28.  
  29.  
  30.  
  31. //入口点
  32. #include"YOTO/EntryPoint.h"

 添加方法：

OrthographicCamera.h:

  1. #pragma once
  2. #include <glm/glm.hpp>
  3. namespace YOTO {
  4. 	class OrthographicCamera
  5. 	{
  6. 	public:
  7. 		OrthographicCamera(float left, float right, float bottom, float top);
  8.  
  9. 		void SetProjection(float left, float right, float bottom, float top);
  10.  
  11. 		const glm::vec3& GetPosition()const { return m_Position; }
  12. 		void SetPosition(const glm::vec3& position) {
  13. 			m_Position = position;
  14. 			RecalculateViewMatrix();
  15. 		}
  16.  
  17. 		float GetRotation()const { return m_Rotation; }
  18. 		void SetRotation(float rotation) {
  19. 			m_Rotation = rotation;
  20. 			RecalculateViewMatrix();
  21. 		}
  22.  
  23. 		const glm::mat4& GetProjectionMatrix()const { return m_ProjectionMatrix; }
  24. 		const glm::mat4& GetViewMatrix()const { return m_ViewMatrix; }
  25. 		const glm::mat4& GetViewProjectionMatrix()const { return m_ViewProjectionMatrix; }
  26. 	private:
  27. 		void RecalculateViewMatrix();
  28. 	private:
  29. 		glm::mat4 m_ProjectionMatrix;
  30. 		glm::mat4 m_ViewMatrix;
  31. 		glm::mat4 m_ViewProjectionMatrix;
  32. 		glm::vec3 m_Position = { 0.0f ,0.0f ,0.0f };
  33. 		float m_Rotation = 0.0f;
  34.  
  35. 	};
  36.  
  37. }
  38.

OrthographicCamera.cpp:

  1. #include "ytpch.h"
  2. #include "OrthographicCamera.h"
  3. #include <glm/gtc/matrix_transform.hpp>
  4. namespace YOTO {
  5. 	OrthographicCamera::OrthographicCamera(float left, float right, float bottom, float top)
  6. 		:m_ProjectionMatrix(glm::ortho(left, right, bottom, top)), m_ViewMatrix(1.0f)
  7. 	{
  8. 		m_ViewProjectionMatrix = m_ProjectionMatrix * m_ViewMatrix;
  9. 	}
  10.  
  11. 	void OrthographicCamera::SetProjection(float left, float right, float bottom, float top) {
  12. 		m_ProjectionMatrix = glm::ortho(left, right, bottom, top);
  13. 		m_ViewProjectionMatrix = m_ProjectionMatrix * m_ViewMatrix;
  14. 	}
  15. 	void OrthographicCamera::RecalculateViewMatrix()
  16. 	{
  17. 		glm::mat4 transform = glm::translate(glm::mat4(1.0f), m_Position) *
  18. 			glm::rotate(glm::mat4(1.0f), glm::radians(m_Rotation), glm::vec3(0, 0, 1));
  19. 		m_ViewMatrix = glm::inverse(transform);
  20. 		m_ViewProjectionMatrix = m_ProjectionMatrix * m_ViewMatrix;
  21. 	}
  22. }

封装控制类：

OrthographicCameraController.h: 

  1. #pragma once
  2. #include "YOTO/Renderer/OrthographicCamera.h"
  3. #include"YOTO/Core/Timestep.h"
  4. #include "YOTO/Event/ApplicationEvent.h"
  5. #include "YOTO/Event/MouseEvent.h"
  6. namespace YOTO {
  7. 	class OrthographicCameraController {
  8. 	public:
  9. 		OrthographicCameraController(float aspectRatio, bool rotation=false );//0,1280
  10. 		void OnUpdate(Timestep ts);
  11. 		void OnEvent(Event& e);
  12. 		OrthographicCamera& GetCamera() {
  13. 			return m_Camera
  14. 				;
  15. 		}
  16. 		const OrthographicCamera& GetCamera()const  {
  17. 			return m_Camera
  18. 				;
  19. 		}
  20.  
  21. 	private:
  22. 		bool OnMouseScrolled(MouseScrolledEvent &e);
  23. 		bool OnWindowResized(WindowResizeEvent& e);
  24. 	private:
  25.  
  26. 		float m_AspectRatio;//横纵比
  27. 		float m_ZoomLevel = 1.0f;
  28. 		OrthographicCamera m_Camera;
  29.  
  30. 		bool m_Rotation;
  31.  
  32. 		glm::vec3 m_CameraPosition = {0.0f,0.0f,0.0f};
  33. 		float m_CameraRotation = 0.0f;
  34. 		float m_CameraTranslationSpeed = 1.0f, m_CameraRotationSpeed = 180.0f;
  35. 	};
  36. }

 OrthographicCameraController.cpp: 

  1. #include "ytpch.h"
  2. #include "OrthographicCameraController.h"
  3. #include"YOTO/Input.h"
  4. #include <YOTO/KeyCode.h>
  5. namespace YOTO {
  6.  
  7. 	OrthographicCameraController::OrthographicCameraController(float aspectRatio, bool rotation)
  8. 		:m_AspectRatio(aspectRatio),m_Camera(-m_AspectRatio*m_ZoomLevel,m_AspectRatio*m_ZoomLevel,-m_ZoomLevel,m_ZoomLevel),m_Rotation(rotation)
  9. 	{
  10.  
  11. 	}
  12.  
  13. 	 
  14. 	void OrthographicCameraController::OnUpdate(Timestep ts)
  15. 	{
  16. 		if (Input::IsKeyPressed(YT_KEY_A)) {
  17. 			m_CameraPosition.x -= m_CameraTranslationSpeed * ts;
  18. 		}
  19. 		else if (Input::IsKeyPressed(YT_KEY_D)) {
  20. 			m_CameraPosition.x += m_CameraTranslationSpeed * ts;
  21. 		}
  22. 		if (Input::IsKeyPressed(YT_KEY_S)) {
  23. 			m_CameraPosition.y -= m_CameraTranslationSpeed * ts;
  24. 		}
  25. 		else if (Input::IsKeyPressed(YT_KEY_W)) {
  26. 			m_CameraPosition.y += m_CameraTranslationSpeed * ts;
  27. 		}
  28. 		if (m_Rotation) {
  29. 			if (Input::IsKeyPressed(YT_KEY_Q)) {
  30. 				m_CameraRotation += m_CameraRotationSpeed * ts;
  31. 			}
  32. 			else if (Input::IsKeyPressed(YT_KEY_E)) {
  33. 				m_CameraRotation -= m_CameraRotationSpeed * ts;
  34. 			}
  35. 			m_Camera.SetRotation(m_CameraRotation);
  36. 		}
  37. 		m_Camera.SetPosition(m_CameraPosition);
  38. 		m_CameraTranslationSpeed = m_ZoomLevel;
  39. 		}
  40.  
  41. 	
  42. 	void OrthographicCameraController::OnEvent(Event& e)
  43. 	{
  44. 		EventDispatcher dispatcher(e);
  45. 		dispatcher.Dispatch<MouseScrolledEvent>(YT_BIND_EVENT_FN(OrthographicCameraController::OnMouseScrolled));
  46. 		dispatcher.Dispatch<WindowResizeEvent>(YT_BIND_EVENT_FN(OrthographicCameraController::OnWindowResized));
  47. 	}
  48. 	bool OrthographicCameraController::OnMouseScrolled(MouseScrolledEvent& e)
  49. 	{
  50. 		m_ZoomLevel -= e.GetYOffset()*0.5f;
  51. 		m_ZoomLevel = std::max(m_ZoomLevel, 0.25f);
  52. 		m_Camera.SetProjection(-m_AspectRatio * m_ZoomLevel, m_AspectRatio * m_ZoomLevel, -m_ZoomLevel, m_ZoomLevel);
  53. 		return false;
  54. 	}
  55. 	bool OrthographicCameraController::OnWindowResized(WindowResizeEvent& e)
  56. 	{
  57. 		m_AspectRatio = (float)e.GetWidth()/(float) e.GetHeight();
  58. 		m_Camera.SetProjection(-m_AspectRatio * m_ZoomLevel, m_AspectRatio * m_ZoomLevel, -m_ZoomLevel, m_ZoomLevel);
  59. 		return false;
  60. 	}
  61. }
  62.

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

测试：

 cool

修改：

添加修改视口的方法：

Render.h:

  1. #pragma once
  2. #include"RenderCommand.h"
  3. #include "OrthographicCamera.h"
  4. #include"Shader.h"
  5. namespace YOTO {
  6.  
  7. 	class Renderer {
  8. 	public:
  9.  
  10.  
  11. 		static void Init();
  12. 		static void OnWindowResize(uint32_t width,uint32_t height);
  13. 		static void BeginScene(OrthographicCamera& camera);
  14. 		static void EndScene();
  15.  
  16. 		static void Submit(const Ref<Shader>& shader, const Ref<VertexArray>& vertexArray,const glm::mat4&transform = glm::mat4(1.0f));
  17. 		
  18. 		inline static RendererAPI::API GetAPI() {
  19. 			return RendererAPI::GetAPI();
  20. 		}
  21. 	private:
  22. 		struct SceneData {
  23. 			glm::mat4 ViewProjectionMatrix;
  24. 		};
  25. 		static SceneData* m_SceneData;
  26. 	};
  27.  
  28. }

Render.cpp: 

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

RenderCommand.h:

  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) {
  21. 			s_RendererAPI->DrawIndexed(vertexArray);
  22. 		}
  23. 		
  24. 	private:
  25. 		static RendererAPI* s_RendererAPI;
  26.  
  27. 	};
  28.  
  29. }
  30.

RenderAPI.h:

  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)=0;
  18.  
  19. 		inline static API GetAPI() { return s_API; }
  20. 	private:
  21. 		static API s_API;
  22. 	};
  23. }
  24.  
  25.

OpenGLRenderAPI.h:

  1. #pragma once
  2. #include"YOTO/Renderer/RendererAPI.h"
  3. namespace YOTO {
  4. 	class OpenGLRendererAPI:public RendererAPI
  5. 	{
  6. 	public:
  7. 		virtual void Init()override;
  8. 		virtual void SetViewport(uint32_t x, uint32_t y, uint32_t width, uint32_t height) override;
  9. 		virtual void SetClearColor(const glm::vec4& color)override;
  10. 		virtual void Clear()override;
  11. 		virtual void DrawIndexed(const Ref<VertexArray>& vertexArray) override;
  12. 	};
  13. }
  14.  
  15.

OpenGLRenderAPI.cpp: 

  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. 	void OpenGLRendererAPI::SetViewport(uint32_t x, uint32_t y, uint32_t width, uint32_t height)
  13. 	{
  14. 		glViewport(x, y, width, height);
  15. 	}
  16. 	void OpenGLRendererAPI::SetClearColor(const glm::vec4& color)
  17. 	{
  18. 		glClearColor(color.r, color.g, color.b, color.a);
  19. 	}
  20. 	void OpenGLRendererAPI::Clear()
  21. 	{
  22. 		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  23. 	}
  24. 	void OpenGLRendererAPI::DrawIndexed(const Ref<VertexArray>& vertexArray)
  25. 	{
  26. 		glDrawElements(GL_TRIANGLES, vertexArray->GetIndexBuffer()->GetCount(), GL_UNSIGNED_INT, nullptr);
  27. 	}
  28. }

OrthographicCameraController.h: 

  1. #pragma once
  2. #include "YOTO/Renderer/OrthographicCamera.h"
  3. #include"YOTO/Core/Timestep.h"
  4. #include "YOTO/Event/ApplicationEvent.h"
  5. #include "YOTO/Event/MouseEvent.h"
  6. namespace YOTO {
  7. 	class OrthographicCameraController {
  8. 	public:
  9. 		OrthographicCameraController(float aspectRatio, bool rotation=false );//0,1280
  10. 		void OnUpdate(Timestep ts);
  11. 		void OnEvent(Event& e);
  12. 		OrthographicCamera& GetCamera() {
  13. 			return m_Camera
  14. 				;
  15. 		}
  16. 		const OrthographicCamera& GetCamera()const  {
  17. 			return m_Camera
  18. 				;
  19. 		}
  20. 		float  GetZoomLevel() { return m_ZoomLevel; }
  21. 		void SetZoomLevel(float level) { m_ZoomLevel = level; }
  22.  
  23. 	private:
  24. 		bool OnMouseScrolled(MouseScrolledEvent &e);
  25. 		bool OnWindowResized(WindowResizeEvent& e);
  26. 	private:
  27.  
  28. 		float m_AspectRatio;//横纵比
  29. 		float m_ZoomLevel = 1.0f;
  30. 		OrthographicCamera m_Camera;
  31.  
  32. 		bool m_Rotation;
  33.  
  34. 		glm::vec3 m_CameraPosition = {0.0f,0.0f,0.0f};
  35. 		float m_CameraRotation = 0.0f;
  36. 		float m_CameraTranslationSpeed = 1.0f, m_CameraRotationSpeed = 180.0f;
  37. 	};
  38. }

OrthographicCameraController.cpp:  

  1. #include "ytpch.h"
  2. #include "OrthographicCameraController.h"
  3. #include"YOTO/Input.h"
  4. #include <YOTO/KeyCode.h>
  5. namespace YOTO {
  6.  
  7. 	OrthographicCameraController::OrthographicCameraController(float aspectRatio, bool rotation)
  8. 		:m_AspectRatio(aspectRatio),m_Camera(-m_AspectRatio*m_ZoomLevel,m_AspectRatio*m_ZoomLevel,-m_ZoomLevel,m_ZoomLevel),m_Rotation(rotation)
  9. 	{
  10.  
  11. 	}
  12.  
  13. 	 
  14. 	void OrthographicCameraController::OnUpdate(Timestep ts)
  15. 	{
  16. 		if (Input::IsKeyPressed(YT_KEY_A)) {
  17. 			m_CameraPosition.x -= m_CameraTranslationSpeed * ts;
  18. 		}
  19. 		else if (Input::IsKeyPressed(YT_KEY_D)) {
  20. 			m_CameraPosition.x += m_CameraTranslationSpeed * ts;
  21. 		}
  22. 		if (Input::IsKeyPressed(YT_KEY_S)) {
  23. 			m_CameraPosition.y -= m_CameraTranslationSpeed * ts;
  24. 		}
  25. 		else if (Input::IsKeyPressed(YT_KEY_W)) {
  26. 			m_CameraPosition.y += m_CameraTranslationSpeed * ts;
  27. 		}
  28. 		if (m_Rotation) {
  29. 			if (Input::IsKeyPressed(YT_KEY_Q)) {
  30. 				m_CameraRotation += m_CameraRotationSpeed * ts;
  31. 			}
  32. 			else if (Input::IsKeyPressed(YT_KEY_E)) {
  33. 				m_CameraRotation -= m_CameraRotationSpeed * ts;
  34. 			}
  35. 			m_Camera.SetRotation(m_CameraRotation);
  36. 		}
  37. 		m_Camera.SetPosition(m_CameraPosition);
  38. 		m_CameraTranslationSpeed = m_ZoomLevel;
  39. 		}
  40.  
  41. 	
  42. 	void OrthographicCameraController::OnEvent(Event& e)
  43. 	{
  44. 		EventDispatcher dispatcher(e);
  45. 		dispatcher.Dispatch<MouseScrolledEvent>(YT_BIND_EVENT_FN(OrthographicCameraController::OnMouseScrolled));
  46. 		dispatcher.Dispatch<WindowResizeEvent>(YT_BIND_EVENT_FN(OrthographicCameraController::OnWindowResized));
  47. 	}
  48. 	bool OrthographicCameraController::OnMouseScrolled(MouseScrolledEvent& e)
  49. 	{
  50. 		m_ZoomLevel -= e.GetYOffset()*0.5f;
  51. 		m_ZoomLevel = std::max(m_ZoomLevel, 0.25f);
  52. 		m_Camera.SetProjection(-m_AspectRatio * m_ZoomLevel, m_AspectRatio * m_ZoomLevel, -m_ZoomLevel, m_ZoomLevel);
  53. 		return false;
  54. 	}
  55. 	bool OrthographicCameraController::OnWindowResized(WindowResizeEvent& e)
  56. 	{
  57. 		m_AspectRatio = (float)e.GetWidth()/(float) e.GetHeight();
  58. 		m_Camera.SetProjection(-m_AspectRatio * m_ZoomLevel, m_AspectRatio * m_ZoomLevel, -m_ZoomLevel, m_ZoomLevel);
  59. 		return false;
  60. 	}
  61. }
  62.

Application.h:

  1. #pragma once
  2. #include"Core.h"
  3. #include"Event/Event.h"
  4. #include"Event/ApplicationEvent.h"
  5. #include "YOTO/Window.h"
  6. #include"YOTO/LayerStack.h"
  7. #include"YOTO/ImGui/ImGuiLayer.h"
  8.  
  9. #include "YOTO/Core/Timestep.h"
  10. #include "YOTO/Renderer/OrthographicCamera.h"
  11. namespace YOTO {
  12. 	class YOTO_API Application
  13. 	{
  14. 	public:
  15. 		Application();
  16. 		virtual ~Application();
  17. 		void Run();
  18. 		void OnEvent(Event& e);
  19. 		void PushLayer(Layer* layer);
  20. 		void PushOverlay(Layer* layer);
  21.  
  22. 		inline static Application& Get() { return *s_Instance; }
  23. 		inline Window& GetWindow() { return *m_Window; }
  24. 	private:
  25. 		bool  OnWindowClosed(WindowCloseEvent& e);
  26. 		bool  OnWindowResize(WindowResizeEvent& e);
  27. 	private:
  28. 		std::unique_ptr<Window>  m_Window;
  29. 		ImGuiLayer* m_ImGuiLayer;
  30. 		bool m_Running = true;
  31. 		bool m_Minimized = false;
  32. 		LayerStack m_LayerStack;
  33. 		Timestep m_Timestep;
  34. 		float m_LastFrameTime = 0.0f;
  35. 		 
  36.  
  37. 	
  38. 	private:
  39. 		static Application* s_Instance;
  40. 	};
  41. 	//在客户端定义
  42. 	Application* CreateApplication();
  43. }

Application.cpp: 

  1. #include"ytpch.h"
  2. #include "Application.h"
  3.  
  4. #include"Log.h"
  5. #include "YOTO/Renderer/Renderer.h"
  6. #include"Input.h"
  7. #include <GLFW/glfw3.h>
  8.  
  9.  
  10. namespace YOTO {
  11. #define BIND_EVENT_FN(x) std::bind(&x, this, std::placeholders::_1)
  12.  
  13. 	Application* Application::s_Instance = nullptr;
  14.  
  15. 	Application::Application()
  16. 	{
  17.  
  18. 		YT_CORE_ASSERT(!s_Instance, "Application需要为空！")
  19. 			s_Instance = this;
  20. 		//智能指针
  21. 		m_Window = std::unique_ptr<Window>(Window::Creat());
  22. 		//设置回调函数
  23. 		m_Window->SetEventCallback(BIND_EVENT_FN(Application::OnEvent));
  24.  
  25. 		m_Window->SetVSync(false);
  26.  
  27. 		Renderer::Init();
  28.  
  29. 		//new一个Layer，放在最后层进行渲染
  30. 		m_ImGuiLayer = new ImGuiLayer();
  31. 		PushOverlay(m_ImGuiLayer);	
  32. 	}
  33. 	Application::~Application() {
  34. 	}
  35. 	/// <summary>
  36. 	/// 所有的Window事件都会在这触发，作为参数e
  37. 	/// </summary>
  38. 	/// <param name="e"></param>
  39. 	void Application::OnEvent(Event& e) {
  40. 		//根据事件类型绑定对应事件
  41. 		EventDispatcher dispatcher(e);
  42. 		dispatcher.Dispatch<WindowCloseEvent>(BIND_EVENT_FN(Application::OnWindowClosed));
  43. 		dispatcher.Dispatch<WindowResizeEvent>(BIND_EVENT_FN(Application::OnWindowResize));
  44. 		//输出事件信息
  45. 		YT_CORE_INFO("Application：{0}", e);
  46. 		for (auto it = m_LayerStack.end(); it != m_LayerStack.begin();) {
  47. 			(*--it)->OnEvent(e);
  48. 			if (e.m_Handled)
  49. 				break;
  50. 		}
  51. 	}
  52.  
  53. 	bool Application::OnWindowClosed(WindowCloseEvent& e) {
  54. 		m_Running = false;
  55. 		return true;
  56. 	}
  57. 	bool Application::OnWindowResize(WindowResizeEvent& e)
  58. 	{
  59. 		if (e.GetWidth()==0||e.GetHeight()==0) {
  60. 			m_Minimized = true;
  61. 			return false;
  62. 		}
  63. 		m_Minimized = false;
  64. 		//调整视口
  65. 		Renderer::OnWindowResize(e.GetWidth(), e.GetHeight());
  66.  
  67.  
  68. 		return false;
  69. 	}
  70. 	void Application::Run() {
  71. 		WindowResizeEvent e(1280, 720);
  72. 		if (e.IsInCategory(EventCategoryApplication)) {
  73. 			YT_CORE_TRACE(e);
  74. 		}
  75. 		if (e.IsInCategory(EventCategoryInput)) {
  76. 			YT_CORE_ERROR(e);
  77. 		}
  78.  
  79. 		while (m_Running)
  80. 		{
  81. 			float time = (float)glfwGetTime();//window平台
  82. 			Timestep timestep = time - m_LastFrameTime;
  83. 			m_LastFrameTime = time;
  84. 			if (!m_Minimized) {
  85.  
  86. 				for (Layer* layer : m_LayerStack) {
  87. 					layer->OnUpdate(timestep);
  88. 				}
  89. 			}	
  90. 			//将ImGui的刷新放到APP中，与Update分开
  91. 			m_ImGuiLayer->Begin();
  92.  
  93. 			for (Layer* layer : m_LayerStack) {
  94. 				layer->OnImGuiRender();
  95. 			}
  96. 			m_ImGuiLayer->End();
  97.  
  98. 			
  99.  
  100. 			m_Window->OnUpdate();
  101. 		}
  102. 	}
  103. 	void Application::PushLayer(Layer* layer) {
  104. 		m_LayerStack.PushLayer(layer);
  105. 		layer->OnAttach();
  106. 	}
  107. 	void Application::PushOverlay(Layer* layer) {
  108. 		m_LayerStack.PushOverlay(layer);
  109. 		layer->OnAttach();
  110. 	}
  111. }

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

添加了新功能，修改窗口大小在OnEvent中。

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

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

  

闽ICP备14008679号