Opengl学习

最新推荐文章于 2025-06-27 21:09:47 发布
原创 最新推荐文章于 2025-06-27 21:09:47 发布 · 331 阅读 · 0 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

环境的配置

因为要使用到这两个库所以说我们要把这两个库连接到工程中。

1.glew glfw(32bit）下载
2.新建c++桌面开发 空白
在这里插入图片描述
3.新增项目
在这里插入图片描述
4.配置设置(项目/属性)
(1)先调成所有配置在这里插入图片描述
(2)依次点击 c/c++常规/附加所包含目录 在里边添加 下好的glew glfw 里include文件
在这里插入图片描述

(3)依次点击 连接器 常规 附加到库目录
在这里插入图片描述

(4)连接器 输入附加到依赖项
在这里插入图片描述
5.在代码中输入头文件

#include<iostream>

#define GLEW_STATIC	

#include <GL/glew.h>
#include <GLFW/glfw3.h>

渲染出一个简单的四边形

#include<iostream>

#define GLEW_STATIC	

#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include"Shader.h"

///通过ESC退出程序
void key_callback(GLFWwindow* window, int key, int scancode, int action, int mode)
{
	if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
		glfwSetWindowShouldClose(window, true);
}

int main()
{	
	//glfw用来实列化窗口
	glfwInit();
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

	GLFWwindow* window = glfwCreateWindow(800, 600, "My Opengl Game", NULL, NULL);




	if (window == NULL)
	{
		printf("Open window failed");
		glfwTerminate();
		return -1;
	}
	glfwMakeContextCurrent(window);

	GLfloat vertices[] = {
		0.5f, 0.5f, 0.0f,  1.0f,0.0f,0.0f,
		0.5f,-0.5f, 0.0f,  0.0f,1.0f,0.0f,
	   -0.5f,-0.5f, 0.0f,  0.0f,0.0f,1.0f,
	   -0.5f, 0.5f, 0.0f,  0.5f,0.5f,0.0f
	};

	unsigned int indices[] = {
		0,1,3,
		1,2,3
	};

	顶点着色器，通过glsl语言来编写
	const char* vertexShaderSource =
		"#version 330 core													 \n"
		"layout(location = 6) in vec3 aPos;								 \n"
		"layout(location = 7) in vec3 aColor;"
		"out vec4 vertexColor;                                               \n"
		"void main(){\n"
		"gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);                           \n"
		"vertexColor = vec4(aColor.x,aColor.y,aColor.z,1.0);\n"
		"}		 \n";

	const char* fragmentShaderSource =
		"#version 330 core						\n"
		"in vec4 vertexColor;                   \n "
		"uniform vec4 ourColor;                \n"
		"out vec4 fragmentcolor;						\n"
		"void main(){							\n"
		"fragmentcolor = vertexColor ;} \n";
		
	//初始化glew用来管理函数的指针
	glewExperimental = true;
	if (glewInit() != GLEW_OK)
	{
		printf("Init Glew failed");
		glfwTerminate();
		return -1;
	}

	//设置viewport视口
	glViewport(0, 0, 800, 600);

	
	//通过
	unsigned int VAO;
	glGenVertexArrays(1, &VAO);
	glBindVertexArray(VAO);

	unsigned int VBO;
	glGenBuffers(1, &VBO);
	glBindBuffer(GL_ARRAY_BUFFER, VBO);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

	unsigned int EBO;
	glGenBuffers(1, &EBO);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

	unsigned int vertexshader;      //编译顶点着色器的源码，通过id来引用
	vertexshader = glcreateshader(gl_vertex_shader);
	glshadersource(vertexshader, 1, &vertexshadersource, null);
	glcompileshader(vertexshader);

	unsigned int fragmentshader;		//编译片段着色器的源码通过id来引用
	fragmentshader = glcreateshader(gl_fragment_shader);
	glshadersource(fragmentshader, 1, &fragmentshadersource, null);
	glcompileshader(fragmentshader);

	unsigned int shaderprogram;   //着色器程序，把着色器合并
	shaderprogram = glcreateprogram();
	glattachshader(shaderprogram, vertexshader);
	glattachshader(shaderprogram, fragmentshader);
	gllinkprogram(shaderprogram);

	glVertexAttribPointer(6, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0); //链接顶点位置属性，如何向opengl解释这些顶点数据
	glEnableVertexAttribArray(6);

	glVertexAttribPointer(7, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(3 * sizeof(float))); //链接顶点颜色属性，如何向opengl解释这些顶点数据
	glEnableVertexAttribArray(7);


	//游戏循环引擎，不希望渲染好直接退出游戏
	while (!glfwWindowShouldClose(window))
	{
		//通过
		glfwSetKeyCallback(window, key_callback);

		//渲染
		//清空颜色缓冲
		glClearColor(0.5f, 0.1f, 0.5f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT);
		
		//激活着色器
		glUseProgram(shaderProgram);
		

		glBindVertexArray(VAO);
		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
		
		//绘制三角形(两种绘制方式)
		//glDrawArrays(GL_TRIANGLES, 0, 3); 
		glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
		

		glfwSwapBuffers(window);
		glfwPollEvents();
	}

	glfwTerminate(); //释放Glfw分配的内存
	return 0;

}

通过读取文件shader来绘制四边形

两个Shader.text文件
fragmentSource.txt

#version 330 core						
in vec4 vertexColor;           
uniform vec4 ourColor;         
out vec4 fragmentcolor;				
	void main()
	{					
		fragmentcolor = vertexColor;

	}

vertexShader.txt

#version 330 core													 
layout(location = 6) in vec3 aPos;							
layout(location = 7) in vec3 aColor;
out vec4 vertexColor;                                        
void main(){
gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);             
vertexColor = vec4(aColor.x,aColor.y,aColor.z,1.0);
}

shader.cpp

#include "Shader.h"
#include<iostream>
#include<fstream>
#include<sstream>
#include <GL/glew.h>
#include <GLFW/glfw3.h>

#define GLEW_STATIC	

using namespace std;

Shader::Shader(const char* vertexPath,const char* fragmentPath)
{
	ifstream vertexFile;
	ifstream fragmentFile;

	stringstream vertexSStream;
	stringstream fragmentSStream;

	//打开文件并且转化为文件流
	vertexFile.open(vertexPath);
	fragmentFile.open(fragmentPath);

	vertexFile.exceptions(ifstream::failbit || ifstream::badbit);
	fragmentFile.exceptions(ifstream::failbit || ifstream::badbit);

	try
	{
		if (!vertexFile.is_open() || !vertexFile.is_open())
		{
			printf("Open file error");
		}
		
		//把文件流读取到缓冲区并且转化为字符串流
		vertexSStream << vertexFile.rdbuf();
		fragmentSStream << fragmentFile.rdbuf();

		//把字符串流转化为字符串
		vertexString = vertexSStream.str();
		fragmentString = fragmentSStream.str();
		
		//把字符出去转换为字符指针
		vertexSource = vertexString.c_str();
		fragmentSource = fragmentString.c_str();		

		//通过id来引用这两个shader
		unsigned int vertex, fragment;

		vertex = glCreateShader(GL_VERTEX_SHADER);
		glShaderSource(vertex,1,&vertexSource,NULL);
		glCompileShader(vertex);
		checkCompileErrors(vertex, "VERTEX");

		fragment = glCreateShader(GL_FRAGMENT_SHADER);
		glShaderSource(fragment, 1,&fragmentSource, NULL);
		glCompileShader(fragment);
		checkCompileErrors(fragment, "FRAGMENT");

		//创建program来把两个shader连接在一起
		ID = glCreateProgram();
		glAttachShader(ID, vertex);
		glAttachShader(ID, fragment);
		glLinkProgram(ID);
		checkCompileErrors(ID, "PROGRAM");
	}
	catch (const std::exception& ex)
	{
		printf(ex.what());
	}
}

void Shader::checkCompileErrors(unsigned int ID,string type)
{
	int success;
	char infoLog[512];

	if (type != "PROGRAM")
	{
		glGetShaderiv(ID, GL_COMPILE_STATUS, &success);
		if(!success)
		{
			glGetShaderInfoLog(ID, 512,NULL, infoLog);
			cout << "shader compile error:" << infoLog << endl;
		}
	}

	else
	{
		glGetProgramiv(ID, GL_LINK_STATUS, &success);
		if(!success)
		{
			glGetProgramInfoLog(ID, 512, NULL, infoLog);
			cout << "program compile error:" << infoLog << endl;			
		}
	}
}

void Shader::use()
{
	glUseProgram(ID);
}

shader.h

#pragma once
#include<string>
class Shader
{
public:
	Shader(const char* vertexPath, const char* fragmentPath);
	std::string vertexString;
	std::string fragmentString;
	const char* vertexSource;
	const char* fragmentSource;

	unsigned int ID;

	void use();

	void checkCompileErrors(unsigned int ID, std::string type);


};

main.cpp

```csharp
#include<iostream>

#define GLEW_STATIC	

#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include"Shader.h"


void key_callback(GLFWwindow* window, int key, int scancode, int action, int mode)
{

	if (key == GLFW_KEY_ESCAPE && action == GLFW_PRESS)
		glfwSetWindowShouldClose(window, true);

}

int main()
{
	
	//glfw用来实列化窗口
	glfwInit();
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

	GLFWwindow* window = glfwCreateWindow(800, 600, "My Opengl Game", NULL, NULL);

	if (window == NULL)
	{
		printf("Open window failed");
		glfwTerminate();
		return -1;
	}
	glfwMakeContextCurrent(window);

	GLfloat vertices[] = {
		0.5f, 0.5f, 0.0f,  1.0f,0.0f,0.0f,
		0.5f,-0.5f, 0.0f,  0.0f,1.0f,0.0f,
	   -0.5f,-0.5f, 0.0f,  0.0f,0.0f,1.0f,
	   -0.5f, 0.5f, 0.0f,  0.5f,0.5f,0.0f
	};

	unsigned int indices[] = {
		0,1,3,
		1,2,3
	};

	//初始化glew用来管理函数的指针
	glewExperimental = true;
	if (glewInit() != GLEW_OK)
	{
		printf("Init Glew failed");
		glfwTerminate();
		return -1;
	}

	//设置viewport视口
	glViewport(0, 0, 800, 600);

	Shader *myShader = new Shader("vertexSource.txt", "fragmentSource.txt");


	unsigned int VAO;
	glGenVertexArrays(1, &VAO);
	glBindVertexArray(VAO);

	unsigned int VBO;
	glGenBuffers(1, &VBO);
	glBindBuffer(GL_ARRAY_BUFFER, VBO);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

	unsigned int EBO;
	glGenBuffers(1, &EBO);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);

	

	glVertexAttribPointer(6, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0); //链接顶点位置属性，如何向opengl解释这些顶点数据
	glEnableVertexAttribArray(6);

	glVertexAttribPointer(7, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)(3 * sizeof(float))); //链接顶点颜色属性，如何向opengl解释这些顶点数据
	glEnableVertexAttribArray(7);


	//游戏循环引擎，不希望渲染好直接退出游戏
	while (!glfwWindowShouldClose(window))
	{
		glfwSetKeyCallback(window, key_callback);

		//渲染
		//清空颜色缓冲
		glClearColor(0.5f, 0.1f, 0.5f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT);

	//	glUseProgram(shaderProgram);//激活着色器
		

		glBindVertexArray(VAO);
		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);

		myShader->use();

	

		//绘制三角形
	//	glDrawArrays(GL_TRIANGLES, 0, 3);
		glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
		

		glfwSwapBuffers(window);
		glfwPollEvents();
	}

	glfwTerminate(); //释放Glfw分配的内存
	return 0;

}

给长方形添加纹理贴图

首先把顶点信息改善

	GLfloat vertices[] = {
		//     ---- 位置 ----       ---- 颜色 ----     - 纹理坐标 -
		0.5f,  0.5f, 0.0f,   1.0f, 0.0f, 0.0f,   1.0f, 1.0f,   // 右上
		0.5f, -0.5f, 0.0f,   0.0f, 1.0f, 0.0f,   1.0f, 0.0f,   // 右下
		-0.5f, -0.5f, 0.0f,   0.0f, 0.0f, 1.0f,   0.0f, 0.0f,   // 左下
		-0.5f,  0.5f, 0.0f,   1.0f, 1.0f, 0.0f,   0.0f, 1.0f    // 左上
	};

如何向vao解释这些uv信息

	glVertexAttribPointer(6, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)0); //链接顶点位置属性，如何向opengl解释这些顶点数据
	glEnableVertexAttribArray(6);

	glVertexAttribPointer(7, 3, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(3 * sizeof(float))); //链接顶点颜色属性，如何向opengl解释这些顶点数据
	glEnableVertexAttribArray(7);

	glVertexAttribPointer(8, 2, GL_FLOAT, GL_FALSE, 8 * sizeof(float), (void*)(6 * sizeof(float))); //链接顶点uv属性，如何向opengl解释这些顶点数据
	glEnableVertexAttribArray(8);

创建贴图缓冲区

unsigned int TexBuffer;
	glGenTextures(1, &TexBuffer);
	glBindTexture(GL_TEXTURE_2D, TexBuffer);

	int width, height, nrChannel;
	unsigned char *data = stbi_load("bird.jpg", &width, &height, &nrChannel, 0);
	if (data)
	{
		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
		glGenerateMipmap(GL_TEXTURE_2D);
	}
	else
	{
		printf("load image error");
	}

	stbi_image_free(data);

加入到顶点着色器中

#version 330 core													 
layout(location = 6) in vec3 aPos;							
layout(location = 7) in vec3 aColor;
layout(location = 8) in vec2 texCoord;

out vec4 vertexColor;   
out vec2 TexCoord;

void main(){
gl_Position = vec4(aPos.x, aPos.y, aPos.z, 1.0);             
vertexColor = vec4(aColor.x,aColor.y,aColor.z,1.0);
TexCoord = texCoord;
}

加入到片段着色器中

#version 330 core						
in vec4 vertexColor;     
in vec2 TexCoord;

uniform sampler2D ourTexture;
         
out vec4 fragmentcolor;				
	void main()
	{					
		fragmentcolor = texture(ourTexture,TexCoord);
	}

首先这个要有一个库的引入soil 简易图形库

创建多个游戏物体并实现相机的移动

实现一个相机类

camera.h

#pragma once
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
class Camera
{
public:
	Camera(glm::vec3 position, glm::vec3 target, glm::vec3 worldup);
	Camera(glm::vec3 position, float pitch, float yaw, glm::vec3 worldup);
	
	glm::vec3 Position;
	glm::vec3 Forward;
	glm::vec3 Right;
	glm::vec3 Up;
	glm::vec3 Worldup;
	float Pitch;
	float Yaw;
	float SenseX = 0.001f;
	float SenseY = 0.001f;
	float speedZ = 0;

	glm::mat4 GetViewMatrix();

	void ProcessMouseMovement(float deltaX, float deltaY);
	void UpdateCameraPos();

private :
	void UpadateCameraVectors();
};

Camera.cpp

#include "Camera.h"

Camera::Camera(glm::vec3 position, glm::vec3 target,glm::vec3 worldup)
{
	Position = position;
	Worldup = worldup;
	Forward = glm::normalize(target - position);
	Right = glm::normalize(glm::cross(Forward, Worldup));
	Up = glm::normalize(glm::cross(Forward, Right));
}

Camera::Camera(glm::vec3 position, float pitch, float yaw, glm::vec3 worldup)
{
	Position = position;
	Worldup = worldup;
	Pitch = pitch;
	Yaw = yaw;
	Forward.x = glm::cos(pitch)*glm::sin(yaw);
	Forward.y = glm::sin(pitch);
	Forward.z = glm::cos(pitch)*glm::cos(yaw);

	Right = glm::normalize(glm::cross(Forward, Worldup));
	Up = glm::normalize(glm::cross(Forward, Right));

}

glm::mat4 Camera::GetViewMatrix()
{
	return glm::lookAt(Position, Position + Forward, Worldup);
}

void Camera::ProcessMouseMovement(float deltaX, float deltaY)
{
	Pitch -= deltaY * SenseX;
	Yaw -= deltaX * SenseY;
	UpadateCameraVectors();
}

void Camera::UpdateCameraPos()
{
	Position += Forward * speedZ*0.1f;
}

//private
void Camera::UpadateCameraVectors()
{
	Forward.x = glm::cos(Pitch)*glm::sin(Yaw);
	Forward.y = glm::sin(Pitch);
	Forward.z = glm::cos(Pitch)*glm::cos(Yaw);
	Right = glm::normalize(glm::cross(Forward, Worldup));
	Up = glm::normalize(glm::cross(Forward, Right));
}

顶点着色器

#version 330 core													 
layout(location = 6) in vec3 aPos;							
//layout(location = 7) in vec3 aColor;
layout(location = 8) in vec2 texCoord;

//out vec4 vertexColor;   
out vec2 TexCoord;

uniform mat4 transform;

uniform mat4 modelMat;
uniform mat4 viewMat;
uniform mat4 projMat;

void main(){
gl_Position = projMat*viewMat*modelMat*vec4(aPos.x, aPos.y, aPos.z, 1.0);//顶点着色器的输出
//vertexColor = vec4(aColor.x,aColor.y,aColor.z,1.0);
TexCoord = texCoord;
}

主函数

#include<iostream>

#define GLEW_STATIC	

#include <GL/glew.h>
#include <GLFW/glfw3.h>
#include"Shader.h"

#define STB_IMAGE_IMPLEMENTATION
#include"stb_image.h"

#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>

#include"Camera.h"

//Camera camera(glm::vec3(0, 0, 3.0f), glm::vec3(0,0 , 0), glm::vec3(0, 1.0f, 0));
Camera camera(glm::vec3(0, 0, 3.0f), glm::radians(-15.0f), glm::radians(180.0f), glm::vec3(0, 1.0f, 0));

void key_callback(GLFWwindow* window, int key, int scancode, int action, int mode)
{
	if (glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS)
	{
		glfwSetWindowShouldClose(window, true);
	}
	if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
	{
		camera.speedZ = 1.0f;
	}
	else if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
	{
		camera.speedZ = -1.0f;
	}
	else
	{
		camera.speedZ = 0;
	}

}

float lastX;
float lastY;
bool firstMouse = true;



void mouse_callback(GLFWwindow *window, double xPos, double yPos)
{
	if (firstMouse == true)
	{
		lastX = xPos;
		lastY = yPos;
		firstMouse = false;
	}
	float deltaX, deltaY;
	deltaX = xPos - lastX;
	deltaY = yPos - lastY;

	lastX = xPos;
	lastY = yPos;

	camera.ProcessMouseMovement(deltaX, deltaY);

//	printf("%f \n", deltaX);
}




int main()
{
	//glfw用来实列化窗口
	glfwInit();
	glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
	glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
	glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);

	GLFWwindow* window = glfwCreateWindow(800, 600, "My Opengl Game", NULL, NULL);

	if (window == NULL)
	{
		printf("Open window failed");
		glfwTerminate();
		return -1;
	}
	glfwMakeContextCurrent(window);
	glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_DISABLED);//关闭鼠标显示
	glfwSetCursorPosCallback(window, mouse_callback);

	GLfloat vertices[] = {
		-0.5f, -0.5f, -0.5f,  0.0f, 0.0f,
		0.5f, -0.5f, -0.5f,  1.0f, 0.0f,
		0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
		0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
		-0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
		-0.5f, -0.5f, -0.5f,  0.0f, 0.0f,

		-0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
		0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
		0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
		0.5f,  0.5f,  0.5f,  1.0f, 1.0f,
		-0.5f,  0.5f,  0.5f,  0.0f, 1.0f,
		-0.5f, -0.5f,  0.5f,  0.0f, 0.0f,

		-0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
		-0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
		-0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
		-0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
		-0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
		-0.5f,  0.5f,  0.5f,  1.0f, 0.0f,

		0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
		0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
		0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
		0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
		0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
		0.5f,  0.5f,  0.5f,  1.0f, 0.0f,

		-0.5f, -0.5f, -0.5f,  0.0f, 1.0f,
		0.5f, -0.5f, -0.5f,  1.0f, 1.0f,
		0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
		0.5f, -0.5f,  0.5f,  1.0f, 0.0f,
		-0.5f, -0.5f,  0.5f,  0.0f, 0.0f,
		-0.5f, -0.5f, -0.5f,  0.0f, 1.0f,

		-0.5f,  0.5f, -0.5f,  0.0f, 1.0f,
		0.5f,  0.5f, -0.5f,  1.0f, 1.0f,
		0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
		0.5f,  0.5f,  0.5f,  1.0f, 0.0f,
		-0.5f,  0.5f,  0.5f,  0.0f, 0.0f,
		-0.5f,  0.5f, -0.5f,  0.0f, 1.0f
	};

	glm::vec3 cubePositions[] = {
		glm::vec3(0.0f,  0.0f,  0.0f),
		glm::vec3(2.0f,  5.0f, -15.0f),
		glm::vec3(-1.5f, -2.2f, -2.5f),
		glm::vec3(-3.8f, -2.0f, -12.3f),
		glm::vec3(2.4f, -0.4f, -3.5f),
		glm::vec3(-1.7f,  3.0f, -7.5f),
		glm::vec3(1.3f, -2.0f, -2.5f),
		glm::vec3(1.5f,  2.0f, -2.5f),
		glm::vec3(1.5f,  0.2f, -1.5f),
		glm::vec3(-1.3f,  1.0f, -1.5f)
	};

	unsigned int indices[] = {
		0,1,3,
		1,2,3
	};

	//初始化glew用来管理函数的指针
	glewExperimental = true;
	if (glewInit() != GLEW_OK)
	{
		printf("Init Glew failed");
		glfwTerminate();
		return -1;
	}

	//设置viewport视口
	glViewport(0, 0, 800, 600);

	glEnable(GL_DEPTH_TEST);//开启深度测试，这样的话会可以判断那些先渲染那些后渲染

	Shader *myShader = new Shader("vertexSource.txt", "fragmentSource.txt");


	unsigned int VAO;
	glGenVertexArrays(1, &VAO);
	glBindVertexArray(VAO);

	

	unsigned int VBO;
	glGenBuffers(1, &VBO);
	glBindBuffer(GL_ARRAY_BUFFER, VBO);
	glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);

	unsigned int EBO;
	glGenBuffers(1, &EBO);
	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
	glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);


	glVertexAttribPointer(6, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0); //链接顶点位置属性，如何向opengl解释这些顶点数据
	glEnableVertexAttribArray(6);



	glVertexAttribPointer(8, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float))); //链接顶点uv属性，如何向opengl解释这些顶点数据
	glEnableVertexAttribArray(8);

	unsigned int TexBufferA;
	glGenTextures(1, &TexBufferA);
	glActiveTexture(GL_TEXTURE0);
	glBindTexture(GL_TEXTURE_2D, TexBufferA);

	int width, height, nrChannel;
	unsigned char *data = stbi_load("bird.jpg", &width, &height, &nrChannel, 0);
	if (data)
	{
		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width, height, 0, GL_RGB, GL_UNSIGNED_BYTE, data);
		glGenerateMipmap(GL_TEXTURE_2D);
	}
	else
	{
		printf("load image error");
	}

	stbi_image_free(data);


	unsigned int TexBufferB;
	glGenTextures(1, &TexBufferB);
	glActiveTexture(GL_TEXTURE3);
	glBindTexture(GL_TEXTURE_2D, TexBufferB);

	int width2, height2, nrChannel2;
	unsigned char *data2 = stbi_load("ground.png", &width2, &height2, &nrChannel2, 0);//加载图片
	if (data2)
	{
		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGB, width2, height2, 0, GL_RGB, GL_UNSIGNED_BYTE, data2);//生成图片
		glGenerateMipmap(GL_TEXTURE_2D);
	}
	else
	{
		printf("load image error");
	}

	stbi_image_free(data2);


	glm::mat4 trans;
	//trans = glm::translate(trans, glm::vec3(-1.0f, 0, 0));

	glm::mat4 modelMat;
	modelMat = glm::rotate(modelMat, glm::radians(-55.0f), glm::vec3(1.0f, 1.0f, 0));
	glm::mat4 viewMat;
	//viewMat = camera.GetViewMatrix();
	glm::mat4 projMat;
	projMat = glm::perspective(glm::radians(45.0f), 800.0f / 600.0f,0.1f, 100.0f);//参数分别是视野，宽高比，近平面和远平面


	//游戏循环引擎，不希望渲染好直接退出游戏
	while (!glfwWindowShouldClose(window))
	{
		//trans = glm::translate(trans, glm::vec3(-0.01f, 0, 0));

		glfwSetKeyCallback(window, key_callback);
		
		//渲染
		//清空颜色缓冲
		glClearColor(0.5f, 0.1f, 0.5f, 1.0f);
		glClear(GL_COLOR_BUFFER_BIT);
		glClear(GL_DEPTH_BUFFER_BIT);

		glActiveTexture(GL_TEXTURE0);
		glBindTexture(GL_TEXTURE_2D, TexBufferA);
		glActiveTexture(GL_TEXTURE3);
		glBindTexture(GL_TEXTURE_2D, TexBufferB);

	//	glBindTexture(GL_TEXTURE_2D, TexBuffer);
		glBindVertexArray(VAO);
		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);

		viewMat = camera.GetViewMatrix();
		for (int i = 0; i < 10; i++)
		{
			glm::mat4 modelMat2;
			modelMat2 = glm::translate(modelMat2, cubePositions[i]);

			myShader->use();
			

			glUniform1i(glGetUniformLocation(myShader->ID, "ourTexture"), 0);
			glUniform1i(glGetUniformLocation(myShader->ID, "ourTexture2"), 3);

			glUniformMatrix4fv(glGetUniformLocation(myShader->ID, "modelMat"), 1, false, glm::value_ptr(modelMat2));
			glUniformMatrix4fv(glGetUniformLocation(myShader->ID, "viewMat"), 1, false, glm::value_ptr(viewMat));
			glUniformMatrix4fv(glGetUniformLocation(myShader->ID, "projMat"), 1, false, glm::value_ptr(projMat));

			glDrawArrays(GL_TRIANGLES, 0, 36);
		}

		glfwSwapBuffers(window);
		glfwPollEvents();
		camera.UpdateCameraPos();
	}

	glfwTerminate(); //释放Glfw分配的内存
	return 0;

}
OpenGL入门学习
XscKernel的专栏 记录工作中做的点滴
12-04 3万+
环境搭建 OpenGL入门学习二 点直线和多边形 在OpenGL中指定顶点 开始绘制 例一画一个圆 例二画一个五角星 例三画出正弦函数的图形 OpenGL入门学习三 关于点 关于直线 关于多边形 OpenGL入门学习四 RGBA颜色 索引颜色 指定清除屏幕用的颜色 指定着色模型 OpenGL入门学习五 模型变换和视图变换 投影变换 视口变换 操作矩阵堆栈 综合举例 OpenGL入门学习六 双缓冲技术
【QOpenGL】layout介绍
Antonio915的博客
05-18 898
本文介绍了在OpenGL中如何指定顶点着色器的layout，并探讨了代码中的layout与着色器中的关系。首先，layout通常直接在GLSL中指定，然后在代码中通过glEnableVertexAttribArray等函数使用。其次，可以通过attributeLocation动态获取着色器中输入变量的layout位置。此外，如果GLSL中没有指定layout，可以在代码中通过bindAttributeLocation延迟指定，但必须在链接程序之前完成。最后，文章提供了一个完整的代码示例，展示了如何在Qt中使
学习openGL
weixin_44715313的博客
04-02 111
https://www.bilibili.com/video/BV1LU4y1a7wq?from=search&seid=17154043429254797654 https://www.bilibili.com/video/BV1st411L76G?from=search&seid=17111768214245739784
openGL学习
weixin_30699741的博客
05-16 113
0.本文章主要记录计算机图形学课上学习的重要知识点及openGL的使用要点，文中部分图片和文字来自https://learnopengl-cn.github.io/ 1.现在使用的opengl都是新版本的opengl，使用可编程管线的方式。主要分两部分，将3D坐标转化成设备的2D坐标，然后将光栅化后的图像添加颜色 2.vertex shader处理顶点，将顶点的3D坐标（一般是物体坐标系），转...
学习OpenGL（一）
孙彬
11-16 425
1.1 什么是OpenGL？ OpenGL是一种应用程序编程接口，它是一种可以对图形硬件设备特性进行访问的软件库。 一个用来渲染图像的OpenGL程序需要执行的主要操作如下： ·从OpenGL的几何图元中设置数据，用于构建形状。 ·使用不同的着色器（shader）对输入的图元数据执行计算操作，判断它们的位置、颜色，以及其他渲染属性。 ·将输入图元的数学描述转化为与屏幕位置对应的像素片元（fragm...
学习OpenGL(一)
无提丶的博客
08-16 331
在learnopengl上学习记录，仅对opengl的简单介绍。
OpenGL的学习
qq_43362405的博客
05-13 320
非常详细的opengl编程入门学习网页链接（百度文库） opengl编程学习
OpenGL学习
tongmeng_yiran的博客
12-11 263
第二节课我学习了如何设置顶点并绘出一个三角形。这是学习OpenGL后写的第一个程序。这是由两个三角形组成的长方形。运行后出现了一个窗口。
OpenGL学习（一）
weixin_43541308的博客
11-18 545
我的第一个OpenGL程序 前言 本文开始记录opengl（开放图形库）的学习，从编译opengl的环境配置，到实现第一个程序的运行。 基于Windows的opengl环境配置 有了解过前人学习opengl的经验，发现不同的版本所需要的依赖库并不相同，但是其实没有关系，因为需要用到相应的API再去下载配置也一样。opengl运行需要至少两个库，一个提供窗口环境，一个提供OpenGL profile加载，据了解红宝书（opengl编程指南）是glut+flew，蓝宝书（OpenGL超级宝典）是glfw+GL3
openGL怎么学习
qq_40544338的博客
03-06 281
一、目的 1、想知道： 二、参考 1、一步步学OpenGL(1) -《打开一个窗口》 https://zhuanlan.zhihu.com/p/26230474 总结：good：这个博主的文章可以多看看，待检测 三、操作： 1、
OpenGL学习 跟着官网教程学习
asiwxy的博客
11-24 756
OpenGL学习 跟着官网教程学习
OPengl学习（一）——初识opengl
疯狂挖掘机的博客
11-25 1184
学习opengl之前的准备工作------
openGL学习(基本窗口)
最新发布
m0_58233509的博客
06-27 755
学习 OpenGL 需要掌握一系列基础知识和技能，这些内容涵盖了计算机图形学的基本概念、编程语言、数学知识以及 OpenGL 的具体 API 使用。以下是学习 OpenGL 所需的主要知识点：1.：了解图形学的基本概念，如像素、分辨率、颜色模型（RGB、RGBA）、光栅化、光栅图形等。：理解图形渲染管线的工作原理，包括顶点处理、光栅化、片段处理等阶段。：熟悉常见的图形对象，如点、线、多边形、纹理、光照等。2.：向量的基本运算（加法、减法、点积、叉积）。：矩阵的基本运算（乘法、逆矩阵、转置）。
深入学习OpenGL：掌握3D图像渲染之道
weixin_28872035的博客
11-03 1825
本文还有配套的精品资源，点击获取 简介：OpenGL是一种广泛用于2D和3D图像渲染的跨语言、跨平台编程接口。本文深入探索了OpenGL 3.3版本的新特性，包括顶点数组对象（VAOs）、顶点着色器和片段着色器的增强，以及GLSL着色器语言的改进。我们还将介绍如何通过实践项目学习OpenGL的渲染逻辑、着色器源代码、资源管理、构建系统和教程文档，帮助学习者掌握现代OpenG...
OpenGL学习历程
jxyb2012的博客
06-10 557
OpenGL学习历程说明OpenGL开发环境搭建GLFW配置GLAD配置VS项目引入第三方库项目案例创建窗口 说明 OpenGL学习中文网 学习OpenGL3.3核心模式（因为早期的立即渲染模式，也称固定渲染管线，这个模式虽然绘图方便，但灵活性不强，OpenGL3.2开始，规范文档开始废弃立即渲染模式，并鼓励开发者在OpenGL的核心模式(Core-profile)下进行开发，为什么要使用3.3版本，因为所有OpenGL的更高的版本都是在3.3的基础上，引入了额外的功能，并没有改动核心架构） 开发环境Wi
OpenGL初学者入门——学习指南【共 9 篇文章】
热门推荐
Wang_Dou_Dou_的博客
11-10 5万+
关键字：OpenGL学习笔记、计算机图形学、OpenGL初学者。
swagger3 离线文档 笔记
makai554892700的专栏
09-17 1416
本文章仅作为个人笔记 官方网站 / 参考文档 / 官方项目 / 个人 demo wagger 的集成与静态文件生成 (在线/离线文档) 新建springboot项目并在build.gradle文件添加相关依赖 # 引用插件(不生成离线文档可以不引入) plugins { id 'org.asciidoctor.convert' version '2.3.0' id "io.github.lhotari.swagger2markup" version "1.3.3.1"
openGL学习—Layout
qq_75066978的博客
04-27 566
通过在OpenGL代码中使用glGetAttribLocation 查询属性位置值（Location）或。顶点着色器接收的是特殊形式的输入，从顶点数据中直接接收输入。为了定义顶点数据如何管理，使用loaction指定输入变量。glBindAttriblocation查询属性。layout标识可以将其连接到顶点数据。
OpenGL笔记之属性变量获取的两种方式：使用layout(location = x) 指定位置和动态获取属性位置
小勇博客
07-13 633
使用指定位置：适合简单场景，位置固定，代码简洁。动态获取属性位置：更灵活，适合动态或复杂场景，避免硬编码位置。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值