Opengl学习

最新推荐文章于 2025-06-27 21:09:47 发布
最新推荐文章于 2025-06-27 21:09:47 发布
阅读量331 收藏
点赞数
CC 4.0 BY-SA版权
分类专栏： Opengl
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/RotatingJump/article/details/110099540

环境的配置

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

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学习
11-04
### OpenGL学习知识点详解 #### 一、OpenGl简介与预备知识 **1.1 引言** 本教程旨在为读者提供一个系统性学习OpenGl的平台。OpenGl是一种跨语言、跨平台的应用程序接口（API），用于渲染二维、三维矢量图形。它是...
OpenGL入门学习
热门推荐
XscKernel的专栏 记录工作中做的点滴
12-04 3万+
环境搭建 OpenGL入门学习二 点直线和多边形 在OpenGL中指定顶点 开始绘制 例一画一个圆 例二画一个五角星 例三画出正弦函数的图形 OpenGL入门学习三 关于点 关于直线 关于多边形 OpenGL入门学习四 RGBA颜色 索引颜色 指定清除屏幕用的颜色 指定着色模型 OpenGL入门学习五 模型变换和视图变换 投影变换 视口变换 操作矩阵堆栈 综合举例 OpenGL入门学习六 双缓冲技术
【QOpenGL】layout介绍
Antonio915的博客
05-18 901
本文介绍了在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（一）
孙彬
11-16 425
1.1 什么是OpenGL？ OpenGL是一种应用程序编程接口，它是一种可以对图形硬件设备特性进行访问的软件库。 一个用来渲染图像的OpenGL程序需要执行的主要操作如下： ·从OpenGL的几何图元中设置数据，用于构建形状。 ·使用不同的着色器（shader）对输入的图元数据执行计算操作，判断它们的位置、颜色，以及其他渲染属性。 ·将输入图元的数学描述转化为与屏幕位置对应的像素片元（fragm...
基于Python实现的OpenGL学习实例设计源码
02-15
本项目提供的是一套基于Python语言实现的OpenGL学习实例，主要设计了27个文件，涵盖了多个实践环节。这些文件中包括了18个Python脚本文件，这些脚本文件是学习OpenGL的核心内容。例如，其中一个脚本文件可能会演示...
OpenGL学习
10-25
这是有有关OpenGL第9版代码库，书本上的数据代码的压缩包
OpenGL学习资料
09-29
OpenGL™ 是行业领域中最为广泛接纳的 2D/3D 图形 API，其自诞生至今已催生了各种计算机平台及设备上的数千优秀应用程序。OpenGL™ 是独立于视窗操作系统或其它操作系统的，亦是网络透明的。在包含CAD、内容创作、...
基于Java语言的OpenGL学习入门级Demo设计源码
10-04
该项目的结构和内容展示了如何将多种文件类型和编程语言结合起来，创建一个功能完备的OpenGL学习Demo。对于初学者来说，通过探索和修改这些文件，可以逐步了解OpenGL图形渲染的流程，掌握从Java调用OpenGL API的基本...
学习OpenGL(一)
无提丶的博客
08-16 331
在learnopengl上学习记录，仅对opengl的简单介绍。
OpenGL的学习
qq_43362405的博客
05-13 320
非常详细的opengl编程入门学习网页链接（百度文库） 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 1186
学习opengl之前的准备工作------
openGL学习(基本窗口)
最新发布
m0_58233509的博客
06-27 755
学习 OpenGL 需要掌握一系列基础知识和技能，这些内容涵盖了计算机图形学的基本概念、编程语言、数学知识以及 OpenGL 的具体 API 使用。以下是学习 OpenGL 所需的主要知识点：1.：了解图形学的基本概念，如像素、分辨率、颜色模型（RGB、RGBA）、光栅化、光栅图形等。：理解图形渲染管线的工作原理，包括顶点处理、光栅化、片段处理等阶段。：熟悉常见的图形对象，如点、线、多边形、纹理、光照等。2.：向量的基本运算（加法、减法、点积、叉积）。：矩阵的基本运算（乘法、逆矩阵、转置）。
OpenGL学习资源推荐：最佳网站汇总
在探讨OpenGL学习资源时，我们首先需要了解OpenGL是什么。OpenGL（Open Graphics Library）是一套用于渲染2D和3D矢量图形的跨语言、跨平台的应用程序编程接口（API）。它在游戏开发、虚拟现实（VR）、科学可视化以及...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值