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

跟着cherno手搓游戏引擎【14】封装opengl

作者：编程领航者 | 2024-01-30 19:24:19

赞

踩

跟着cherno手搓游戏引擎【14】封装opengl

本节先把代码粘上，后续会慢慢把注释都给加上，先看代码了解个大概（待更新）

前置：

RendererAPI.h:

  1. #pragma once
  2. namespace YOTO {
  3. 	enum class RendererAPI {
  4. 		None = 0,
  5. 		OpenGL=1
  6. 	};
  7. 	class Renderer {
  8. 	public:
  9. 		inline static RendererAPI GetAPI() {
  10. 			return s_RendererAPI;
  11. 		}
  12. 		static RendererAPI s_RendererAPI;
  13. 	};
  14.  
  15. }

 RendererAPI.cpp:

  1. #include"ytpch.h"
  2. #include"Renderer.h"
  3. namespace YOTO {
  4. 	RendererAPI Renderer::s_RendererAPI = RendererAPI::OpenGL;
  5. }

抽象：

buffer.h:

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

buffer.cpp:

  1. #include"ytpch.h"
  2. #include"Buffer.h"
  3. #include "Renderer.h"
  4.  
  5. #include "Platform/OpenGL/OpenGLBuffer.h"
  6.  
  7. namespace YOTO {
  8. 	VertexBuffer* VertexBuffer::Create(float* vertices, uint32_t size)
  9. 	{
  10. 		switch (Renderer::GetAPI())
  11. 		{
  12. 		case RendererAPI::None:
  13. 			YT_CORE_ASSERT(false,"Buffer：API为None不支持");
  14. 			return nullptr;
  15. 		case RendererAPI::OpenGL:
  16. 			return new OpenGLVertexBuffer(vertices,size);
  17. 		}
  18. 		YT_CORE_ASSERT(false,"Buffer：未知API");
  19. 		return nullptr;
  20. 	}
  21. 	IndexBuffer* IndexBuffer::Create(uint32_t* indices, uint32_t size)
  22. 	{
  23. 		switch (Renderer::GetAPI())
  24. 		{
  25. 		case RendererAPI::None:
  26. 			YT_CORE_ASSERT(false, "Buffer：API为None不支持");
  27. 			return nullptr;
  28. 		case RendererAPI::OpenGL:
  29. 			return new OpenGLIndexBuffer(indices, size);
  30. 		}
  31. 		YT_CORE_ASSERT(false, "Buffer：未知API");
  32. 		return nullptr;
  33. 	}
  34. }

 VertexArray.h:

  1. #pragma once
  2. #include"YOTO/Renderer/Buffer.h"
  3. namespace YOTO {
  4. 	
  5. 	class VertexArray {
  6. 	public:
  7. 		virtual~VertexArray() {}
  8.  
  9. 		virtual void Bind() const = 0;
  10. 		virtual void UnBind() const = 0;
  11. 		virtual void AddVertexBuffer(const std::shared_ptr<VertexBuffer>&vertexBuffer) = 0;
  12. 		virtual void AddIndexBuffer(const std::shared_ptr<IndexBuffer>& indexBuffer) = 0;
  13. 		virtual const  std::vector<std::shared_ptr<VertexBuffer>>& GetVertexBuffers()const = 0;
  14. 		virtual const std::shared_ptr<IndexBuffer>& GetIndexBuffer()const = 0;
  15. 		static  VertexArray* Create();
  16. 	};
  17. }
  18.  
  19.

 VertexArray.cpp:

  1. #include "ytpch.h"
  2. #include "VertexArray.h"
  3. #include"Renderer.h"
  4. #include "Platform/OpenGL/OpenGLVertexArray.h"
  5. namespace YOTO {
  6. 	VertexArray* VertexArray::Create()
  7. 	{
  8. 		switch (Renderer::GetAPI())
  9. 		{
  10. 		case RendererAPI::None:
  11. 			YT_CORE_ASSERT(false, "Buffer：API为None不支持");
  12. 			return nullptr;
  13. 		case RendererAPI::OpenGL:
  14. 			return new OpenGLVertexArray();
  15. 		}
  16. 		YT_CORE_ASSERT(false, "Buffer：未知API");
  17. 		return nullptr;
  18. 	}
  19. }

实现：

OpenGLBuffer.h:

  1. #pragma once
  2. #include "YOTO/Renderer/Buffer.h"
  3. namespace YOTO {
  4. 	class OpenGLVertexBuffer : public VertexBuffer {
  5. 	public:
  6. 		OpenGLVertexBuffer(float* vertices, uint32_t size);
  7. 		virtual~OpenGLVertexBuffer();
  8. 		virtual void Bind()const override;
  9. 		virtual void UnBind()const override;
  10.  
  11. 		virtual void SetLayout(const BufferLayout& layout)  override {
  12. 			m_Layout = layout;
  13. 		}
  14. 		virtual const BufferLayout& GetLayout()const override {
  15. 			return m_Layout;
  16. 		}
  17. 	private: 
  18. 		uint32_t m_RendererID;
  19. 		BufferLayout m_Layout;
  20. 	};
  21.  
  22. 	class OpenGLIndexBuffer : public IndexBuffer {
  23. 	public:
  24. 		OpenGLIndexBuffer(uint32_t* indices, uint32_t count);
  25. 		virtual~OpenGLIndexBuffer();
  26. 		virtual void Bind()const;
  27. 		virtual void UnBind()const;
  28. 		virtual uint32_t GetCount() const {
  29. 			return m_Count;
  30. 		};
  31. 	private:
  32. 		uint32_t m_RendererID;
  33. 		uint32_t m_Count;
  34. 	};
  35. }

 OpenGLBuffer.cpp:

  1. #include"ytpch.h"
  2. #include"OpenGLBuffer.h"
  3. #include <glad/glad.h>
  4. namespace YOTO {
  5.  
  6. // VertexBuffer 
  7.  
  8. 	OpenGLVertexBuffer::OpenGLVertexBuffer(float* vertices, uint32_t size)
  9. 	{	 
  10. 		
  11. 		glCreateBuffers(1, &m_RendererID);
  12. 		glBindBuffer(GL_ARRAY_BUFFER, m_RendererID);
  13. 		glBufferData(GL_ARRAY_BUFFER, size, vertices, GL_STATIC_DRAW);
  14. 	}
  15. 	OpenGLVertexBuffer::~OpenGLVertexBuffer()
  16. 	{ 
  17. 		glDeleteBuffers(1, &m_RendererID);
  18. 	}
  19. 	void OpenGLVertexBuffer::Bind() const
  20. 	{
  21. 		glBindBuffer(GL_ARRAY_BUFFER, m_RendererID);
  22. 	}
  23. 	void OpenGLVertexBuffer::UnBind() const
  24. 	{
  25. 		glBindBuffer(GL_ARRAY_BUFFER, 0);
  26. 	}
  27.  
  28. 	
  29. 	// IndexBuffer /
  30. 	
  31. 	OpenGLIndexBuffer::OpenGLIndexBuffer(uint32_t* indices, uint32_t count)
  32. 		:m_Count(count)
  33. 	{
  34. 		glCreateBuffers(1, &m_RendererID);
  35. 		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_RendererID);
  36. 		glBufferData(GL_ELEMENT_ARRAY_BUFFER, count*sizeof(uint32_t), indices, GL_STATIC_DRAW);
  37. 	}
  38. 	OpenGLIndexBuffer::~OpenGLIndexBuffer()
  39. 	{
  40. 		glDeleteBuffers(1, &m_RendererID);
  41. 	}
  42. 	void OpenGLIndexBuffer::Bind() const
  43. 	{
  44. 		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_RendererID);
  45. 	}
  46. 	void OpenGLIndexBuffer::UnBind() const
  47. 	{
  48. 		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
  49. 	}
  50. }

 OpenGLVertexArray.h:

  1. #pragma once
  2. #include"YOTO/Renderer/VertexArray.h"
  3. namespace YOTO {
  4. 	class OpenGLVertexArray:public VertexArray
  5. 	{
  6. 	public :
  7. 		OpenGLVertexArray();
  8. 		virtual ~OpenGLVertexArray();
  9. 		virtual void Bind() const override;
  10. 		virtual void UnBind() const override;
  11.  
  12. 		virtual void AddVertexBuffer(const std::shared_ptr<VertexBuffer>& vertexBuffer)override;
  13. 		virtual void AddIndexBuffer(const std::shared_ptr<IndexBuffer>& indexBuffer)override;
  14.  
  15. 		virtual const std::vector<std::shared_ptr<VertexBuffer>>& GetVertexBuffers()const {
  16. 			return m_VertexBuffers;
  17. 		}
  18. 		virtual const std::shared_ptr<IndexBuffer>& GetIndexBuffer()const {
  19. 			return m_IndexBuffers;
  20. 		}
  21. 	private:
  22. 		uint32_t m_RendererID;
  23. 		std::vector<std::shared_ptr<VertexBuffer>> m_VertexBuffers;
  24. 		std::shared_ptr<IndexBuffer> m_IndexBuffers;
  25. 	};
  26.  
  27. }
  28.  
  29.

  OpenGLVertexArray.cpp:

  1. #include "ytpch.h"
  2. #include "OpenGLVertexArray.h"
  3. #include <glad/glad.h>
  4. namespace YOTO {
  5. 	static GLenum ShaderDataTypeToOpenGLBaseType(ShaderDataType type) {
  6. 		switch (type)
  7. 		{
  8. 		case YOTO::ShaderDataType::Float:
  9. 			return GL_FLOAT;
  10. 		case YOTO::ShaderDataType::Float2:
  11. 			return GL_FLOAT;
  12. 		case YOTO::ShaderDataType::Float3:
  13. 			return GL_FLOAT;
  14. 		case YOTO::ShaderDataType::Float4:
  15. 			return GL_FLOAT;
  16. 		case YOTO::ShaderDataType::Mat3:
  17. 			return GL_FLOAT;
  18. 		case YOTO::ShaderDataType::Mat4:
  19. 			return GL_FLOAT;
  20. 		case YOTO::ShaderDataType::Int:
  21. 			return GL_INT;
  22. 		case YOTO::ShaderDataType::Int2:
  23. 			return GL_INT;
  24. 		case YOTO::ShaderDataType::Int3:
  25. 			return GL_INT;
  26. 		case YOTO::ShaderDataType::Int4:
  27. 			return GL_INT;
  28. 		case YOTO::ShaderDataType::Bool:
  29. 			return GL_BOOL;
  30. 		}
  31. 		return 0;
  32. 	}
  33. 	OpenGLVertexArray::OpenGLVertexArray()
  34. 	{
  35. 		glCreateVertexArrays(1, &m_RendererID);
  36. 	}
  37. 	OpenGLVertexArray::~OpenGLVertexArray()
  38. 	{
  39. 		glDeleteVertexArrays(1, &m_RendererID);
  40. 	}
  41. 	void OpenGLVertexArray::Bind() const
  42. 	{
  43. 		glBindVertexArray(m_RendererID);
  44. 	}
  45. 	void OpenGLVertexArray::UnBind() const
  46. 	{
  47. 		glBindVertexArray(0);
  48. 	}
  49. 	void OpenGLVertexArray::AddVertexBuffer(const std::shared_ptr<VertexBuffer>& vertexBuffer)
  50. 	{
  51. 		YT_CORE_ASSERT(vertexBuffer->GetLayout().GetElements().size(), "OpenGLVertexArray:VertexBuffer没有布局（Layout）")
  52. 		glBindVertexArray(m_RendererID);
  53. 		vertexBuffer->Bind();
  54. 		
  55. 		uint32_t index = 0;
  56. 		const auto& layout = vertexBuffer->GetLayout();
  57. 		for (const auto& element : layout) {
  58. 			glEnableVertexAttribArray(index);
  59. 			//设置缓冲区数据格式：缓冲区序号、顶点属性的大小、什么数据类型、会不会被归一化、
  60. 			glVertexAttribPointer(index,
  61. 				element.GetComponentCount(),
  62. 				ShaderDataTypeToOpenGLBaseType(element.Type),
  63. 				element.Normalized ? GL_TRUE : GL_FALSE,
  64. 				layout.GetStride(),
  65. 				(const void*)element.Offset);
  66. 			index++;
  67. 		}
  68. 		m_VertexBuffers.push_back(vertexBuffer);
  69. 	}
  70. 	void OpenGLVertexArray::AddIndexBuffer(const std::shared_ptr<IndexBuffer>& indexBuffer)
  71. 	{
  72. 		glBindVertexArray(m_RendererID);
  73. 		indexBuffer->Bind();
  74. 		m_IndexBuffers = indexBuffer;
  75. 	}
  76. }

调用：

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/Renderer/Shader.h>
  10. #include <YOTO/Renderer/Buffer.h>
  11. #include <YOTO/Renderer/VertexArray.h>
  12. namespace YOTO {
  13. 	class YOTO_API Application
  14. 	{
  15. 	public:
  16. 		Application();
  17. 		virtual ~Application();
  18. 		void Run();
  19. 		void OnEvent(Event &e);
  20. 		void PushLayer(Layer* layer);
  21. 		void PushOverlay(Layer* layer);
  22.  
  23. 		inline static Application& Get() {return * s_Instance;}
  24. 		inline Window& GetWindow() { return *m_Window; }
  25. 	private:
  26. 		bool  OnWindowClosed(WindowCloseEvent& e);
  27. 		std::unique_ptr<Window>  m_Window;
  28. 		ImGuiLayer *  m_ImGuiLayer;
  29. 		bool m_Running = true;
  30. 		LayerStack m_LayerStack;
  31. 		
  32. 		//unsigned int m_VertexArray;
  33. 		std::shared_ptr<Shader> m_Shader;
  34. 		std::shared_ptr<VertexArray> m_VertexArray;
  35.  
  36.  
  37. 		std::shared_ptr<Shader> m_BlueShader;
  38. 		std::shared_ptr<VertexArray> m_SquareVA;
  39.  
  40.  
  41.  
  42. 		static Application* s_Instance;
  43. 	};
  44. 	//在客户端定义
  45. 	Application* CreateApplication();
  46. }
  47.

 Application.cpp:

  1. #include"ytpch.h"
  2. #include "Application.h"
  3.  
  4. #include"Log.h"
  5. #include<glad/glad.h>
  6. #include"Input.h"
  7.  
  8.  
  9. namespace YOTO {
  10. #define BIND_EVENT_FN(x) std::bind(&x, this, std::placeholders::_1)
  11.  
  12. 	 Application* Application::s_Instance = nullptr;
  13.  
  14. 	Application::Application() {
  15.  
  16. 		YT_CORE_ASSERT(!s_Instance, "Application需要为空！")
  17. 		s_Instance = this;
  18. 		//智能指针
  19. 		m_Window = std::unique_ptr<Window>(Window::Creat());
  20. 		//设置回调函数
  21. 		m_Window->SetEventCallback(BIND_EVENT_FN(Application::OnEvent));
  22. 		//new一个Layer，放在最后层进行渲染
  23. 		m_ImGuiLayer = new ImGuiLayer();
  24. 		PushOverlay(m_ImGuiLayer);  
  25. 		//unsigned int id;
  26. 		//glGenBuffers(1, &id);
  27.  
  28. 		uint32_t indices[3] = { 0,1,2 };
  29. 		float vertices[3 * 7] = {
  30. 			-0.5f,-0.5f,0.0f, 0.8f,0.2f,0.8f,1.0f,
  31. 			0.5f,-0.5f,0.0f,  0.2f,0.3f,0.8f,1.0f,
  32. 			0.0f,0.5f,0.0f,   0.8f,0.8f,0.2f,1.0f,
  33. 		};
  34. 		m_VertexArray.reset(VertexArray::Create());
  35.  
  36.  
  37. 		//顶点数组：
  38. 		//glGenVertexArrays(1, &m_VertexArray);
  39. 		//glBindVertexArray(m_VertexArray);
  40. 		//顶点缓冲区
  41. 		//glGenBuffers(1, &m_VertexBuffer);
  42. 		//glBindBuffer(GL_ARRAY_BUFFER,m_VertexBuffer);
  43. 		//把数据传送给gpu，GL_STATIC_DRAW不断的用新数据刷新数组。告诉opengl这个缓冲区的数据布局
  44. 		//glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
  45. 		std::shared_ptr<VertexBuffer> m_VertexBuffer;
  46. 		m_VertexBuffer.reset(VertexBuffer::Create(vertices, sizeof(vertices)));
  47.  
  48. 	
  49.  
  50. 		//启用数据的索引0
  51. 		//glEnableVertexAttribArray(0);
  52. 		//设置缓冲区数据格式：缓冲区序号、顶点属性的大小、什么数据类型、会不会被归一化、
  53. 		//glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float),nullptr);
  54. 		{
  55. 			BufferLayout setlayout = {
  56.  
  57. 	{ShaderDataType::Float3,"a_Position"},
  58. 		{ShaderDataType::Float4,"a_Color"}
  59. 			};
  60. 			m_VertexBuffer->SetLayout(setlayout);
  61.  
  62. 		}
  63.  
  64. 		//uint32_t index = 0;
  65. 		//const auto& layout = m_VertexBuffer->GetLayout();
  66. 		//for (const auto& element : layout) {
  67. 		//	glEnableVertexAttribArray(index);
  68. 		//	//设置缓冲区数据格式：缓冲区序号、顶点属性的大小、什么数据类型、会不会被归一化、
  69. 		//	glVertexAttribPointer(index,
  70. 		//		element.GetComponentCount(), 
  71. 		//		ShaderDataTypeToOpenGLBaseType(element.Type), 
  72. 		//		element.Normalized?GL_TRUE:GL_FALSE,
  73. 		//		layout.GetStride() ,
  74. 		//		(const void *)element.Offset);
  75. 		//	index++;
  76. 		//}
  77. 		 
  78. 		m_VertexArray->AddVertexBuffer(m_VertexBuffer);
  79. 		
  80. 		 
  81. 		//创建索引缓冲区
  82. 		//glGenBuffers(1, &m_IndexBuffer);
  83. 		//glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_IndexBuffer);
  84. 		//设置缓冲区格式
  85. 		//glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
  86. 		std::shared_ptr<IndexBuffer>m_IndexBuffer;
  87. 		m_IndexBuffer.reset(IndexBuffer::Create(indices, sizeof(indices)/sizeof(uint32_t)));
  88.  
  89. 		m_VertexArray->AddIndexBuffer(m_IndexBuffer);
  90. 		//着色器
  91. 		//顶点布局
  92. 		std::string vertexSource = R"(
  93. 		#version 330 core
  94. 		layout(location = 0) in vec3 a_Position;
  95. 		layout(location = 1) in vec4 a_Color;
  96. 		out vec3 v_Position;
  97. 		out vec4 v_Color;
  98. 		void main(){
  99. 		v_Position=a_Position;
  100. 		v_Color=a_Color;
  101. 		gl_Position =vec4( a_Position+0.5,1.0);
  102. 		}
  103. 		)";
  104. 		//绘制颜色
  105. 		std::string fragmentSource = R"(
  106. 		#version 330 core
  107. 		layout(location = 0) out vec4 color;
  108. 		in vec3 v_Position;
  109. 		in vec4 v_Color;
  110. 		void main(){
  111. 		color=vec4(v_Color);
  112. 		}
  113. 		)";
  114. 		m_Shader.reset(new Shader(vertexSource, fragmentSource));
  115.  
  116. 		///测试/
  117.  
  118. 		m_SquareVA.reset(VertexArray::Create());
  119.  
  120. 		float squareVertices[3 * 4] = {
  121. 			-0.5f,-0.5f,0.0f,
  122. 			0.5f,-0.5f,0.0f, 
  123. 			0.5f,0.5f,0.0f,
  124. 			-0.5f,0.5f,0.0f
  125. 		};
  126. 		std::shared_ptr<VertexBuffer> squareVB;
  127. 		squareVB.reset(VertexBuffer::Create(squareVertices, sizeof(squareVertices)));
  128. 		squareVB->SetLayout({
  129. 			{ShaderDataType::Float3,"a_Position"}
  130. 		});
  131. 		m_SquareVA->AddVertexBuffer(squareVB);
  132. 		uint32_t squareIndices[6] = { 0,1,2,2,3,0 };
  133. 		std::shared_ptr<IndexBuffer> squareIB; 
  134.  
  135. 		squareIB.reset((IndexBuffer::Create(squareIndices, sizeof(squareIndices) / sizeof(uint32_t))));
  136.  
  137. 		m_SquareVA->AddIndexBuffer(squareIB);
  138. 		
  139.  
  140. 		//测试：
  141. 		std::string BlueShaderVertexSource = R"(
  142. 		#version 330 core
  143. 		layout(location = 0) in vec3 a_Position;
  144. 		out vec3 v_Position;
  145. 		void main(){
  146. 		v_Position=a_Position;
  147. 		gl_Position =vec4( a_Position,1.0);
  148. 		}
  149. 		)";
  150. 		//绘制颜色
  151. 		std::string BlueShaderFragmentSource = R"(
  152. 		#version 330 core
  153. 		layout(location = 0) out vec4 color;
  154. 		in vec3 v_Position;
  155. 		void main(){
  156. 		color=vec4(0.2,0.3,0.8,1.0);
  157. 		}
  158. 		)";
  159. 		m_BlueShader.reset(new Shader(BlueShaderVertexSource, BlueShaderFragmentSource));
  160. 		
  161. 		//shader
  162. 	}
  163. 	Application::~Application() {
  164.  
  165. 	}
  166. 	/// <summary>
  167. 	/// 所有的Window事件都会在这触发，作为参数e
  168. 	/// </summary>
  169. 	/// <param name="e"></param>
  170. 	void Application::OnEvent(Event& e) {
  171. 		//根据事件类型绑定对应事件
  172. 		EventDispatcher dispatcher(e);
  173. 		dispatcher.Dispatch<WindowCloseEvent>(BIND_EVENT_FN(Application::OnWindowClosed));
  174. 		//输出事件信息
  175. 		YT_CORE_INFO("Application：{0}",e);
  176. 		for (auto it = m_LayerStack.end(); it != m_LayerStack.begin();) {
  177. 			(*--it)->OnEvent(e);
  178. 			if (e.m_Handled)
  179. 				break;
  180. 		}
  181. 	}
  182.  
  183. 	bool Application::OnWindowClosed(WindowCloseEvent& e) {
  184. 		m_Running = false;
  185. 		return true;
  186. 	}
  187. 	void Application::Run() {
  188. 		WindowResizeEvent e(1280, 720);
  189. 		if (e.IsInCategory(EventCategoryApplication)) {
  190. 			YT_CORE_TRACE(e);
  191. 		}
  192. 		if (e.IsInCategory(EventCategoryInput)) {
  193. 			YT_CORE_ERROR(e);
  194. 		}
  195.  
  196. 		while (m_Running)
  197. 		{
  198. 			glClearColor(0.2f, 0.2f, 0.2f,1);
  199. 			glClear(GL_COLOR_BUFFER_BIT);
  200. 			
  201. 			m_BlueShader->Bind();
  202. 			m_SquareVA->Bind();
  203. 			glDrawElements(GL_TRIANGLES, m_SquareVA->GetIndexBuffer()->GetCount(), GL_UNSIGNED_INT, nullptr);
  204. 			//glBindVertexArray(m_VertexArray);
  205. 			m_Shader->Bind();
  206. 			m_VertexArray->Bind();
  207. 			glDrawElements(GL_TRIANGLES,m_VertexArray->GetIndexBuffer()->GetCount(),GL_UNSIGNED_INT,nullptr); 
  208.  
  209. 			for (Layer* layer : m_LayerStack) {
  210. 				layer->OnUpdate();
  211. 			}
  212. 			//将ImGui的刷新放到APP中，与Update分开
  213. 			m_ImGuiLayer->Begin();
  214. 			
  215. 			for (Layer* layer : m_LayerStack) {
  216. 				layer->OnImGuiRender();
  217. 			}
  218. 			m_ImGuiLayer->End();
  219. 			m_Window->OnUpdate();
  220. 		}
  221. 	}
  222. 	void Application::PushLayer(Layer* layer) {
  223. 		m_LayerStack.PushLayer(layer);
  224. 		layer->OnAttach();
  225. 	}
  226. 	void Application::PushOverlay(Layer* layer) {
  227. 		m_LayerStack.PushOverlay(layer);
  228. 		layer->OnAttach();
  229. 	}
  230. }

 测试：

shader就不改了，随便一测试画出来个矩形就对了

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

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

  

闽ICP备14008679号