使用OpenGL进行绘制，包含万向节摄像机、着色器、VAO、贴图、立方体圆柱圆球圆环圆锥的面片生成和绘制

已于 2025-01-23 16:55:54 修改
阅读量143 收藏
点赞数 2
CC 4.0 BY-SA版权
分类专栏： OpenGL 文章标签： 着色器
于 2025-01-17 18:23:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/qq_32563489/article/details/145212562 
#pragma once
#include "glad/glad.h"
#include "KHR/khrplatform.h"
#include "gl/GL.h"
#include "assert.h"
#include <string>
#include <fstream>
#include <sstream>
#include <iostream>


class GiShaderProgram
{
   
   
public:

	GiShaderProgram();
	GiShaderProgram(const char* vertexPath, const char* fragmentPath);
	~GiShaderProgram();
	void Release();
	void use();
	void SetShaderPath(const char* vertexPath, const char* fragmentPath);
	void setBool(const std::string& name, bool value) const;
	// ------------------------------------------------------------------------
	void setInt(const std::string& name, int value) const;
	// ------------------------------------------------------------------------
	void setFloat(const std::string& name, float value) const;
	void setMat4d(const std::string& name, double* pMat) const;
	void setMat4f(const std::string& name, float* pMat) const;
	void setVec4f(const std::string& name, float* pvec) const;
	void setVec3f(const std::string& name, float* pvec) const;
	void setVec3f(const std::string& name, float para1, float para2, float para3) const;

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

	unsigned int ID;
};

class GiVAO
{
   
   
public:

	GiVAO();
	GiVAO(double *pPts, size_t iNum, int ipara1, int ipara2, int ipara3);
	GiVAO(float* pPts, size_t iNum, int ipara1, int ipara2, int ipara3);
	~GiVAO();
	void SetPts(double* pPts, size_t iNum, int ipara1, int ipara2, int ipara3);
	void SetPts(float* pPts, size_t iNum, int ipara1, int ipara2, int ipara3);
	void Use();
	void DrawArrays(int type, int iFirst, int iCount);

private:
	unsigned int ID;
	unsigned int iVBO;
};

class GiFrameBuffer
{
   
   
public:

	GiFrameBuffer();
	GiFrameBuffer(const unsigned int iWidth, const unsigned int iHight);
	~GiFrameBuffer();
	void Use();
	void ResetRect(const unsigned int iWidth, const unsigned int iHight);
	unsigned int GetTextureID();

private:
	unsigned int ID;
	unsigned int iTexturebuffer;
	unsigned int iRbo;
};

class GiTexture
{
   
   
public:

	GiTexture();
	GiTexture(const char* vertexPath);
	GiTexture(GLbyte* pDIB, int iWidth, int iHeight, int iFormat, bool bIsLinear = true);
	~GiTexture();
	void Release();
	void use();
	unsigned int GetID();

private:
	unsigned int loadTexture(char const* path);

	unsigned int ID;
};


static GLenum CheckGLError()
{
   
   
	GLenum errorCode;
	while ((errorCode = glGetError()) != GL_NO_ERROR)
	{
   
   
		std::string error;
		switch (errorCode)
		{
   
   
		case GL_INVALID_ENUM:                  error = "INVALID_ENUM"; break;
		case GL_INVALID_VALUE:                 error = "INVALID_VALUE"; break;
		case GL_INVALID_OPERATION:             error = "INVALID_OPERATION"; break;
		/*case GL_STACK_OVERFLOW:                error = "STACK_OVERFLOW"; break;
		case GL_STACK_UNDERFLOW:               error = "STACK_UNDERFLOW"; break;*/
		case GL_OUT_OF_MEMORY:                 error = "OUT_OF_MEMORY"; break;
		case GL_INVALID_FRAMEBUFFER_OPERATION: error = "INVALID_FRAMEBUFFER_OPERATION"; break;
		}
		assert(false);
	}
	return errorCode;
}

#include "GiShaderProgram.h"
#include "stb_image.h"

GiShaderProgram::GiShaderProgram()
{
   
   
	ID = 0;
}

GiShaderProgram::GiShaderProgram(const char* vertexPath, const char* fragmentPath)
{
   
   
	ID = 0;
	SetShaderPath(vertexPath, fragmentPath);
}

GiShaderProgram::~GiShaderProgram()
{
   
   
	if (ID != 0)
	{
   
   
		glDeleteProgram(ID);
		CheckGLError();
		ID = 0;
	}
}

void GiShaderProgram::Release()
{
   
   
	if (ID != 0)
	{
   
   
		glDeleteProgram(ID);
		CheckGLError();
		ID = 0;
	}
}

void GiShaderProgram::use()
{
   
   
	glUseProgram(ID);
	CheckGLError();
}

void GiShaderProgram::SetShaderPath(const char* vertexPath, const char* fragmentPath)
{
   
   
	if (ID != 0)
	{
   
   
		glDeleteProgram(ID);
		CheckGLError();
		ID = 0;
	}

	// 1. retrieve the vertex/fragment source code from filePath
	std::string vertexCode;
	std::string fragmentCode;
	std::ifstream vShaderFile;
	std::ifstream fShaderFile;
	// ensure ifstream objects can throw exceptions:
	vShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);
	fShaderFile.exceptions(std::ifstream::failbit | std::ifstream::badbit);

	try
	{
   
   
		// open files
		vShaderFile.open(vertexPath);
		fShaderFile.open(fragmentPath);
		std::stringstream vShaderStream, fShaderStream;
		// read file's buffer contents into streams
		vShaderStream << vShaderFile.rdbuf();
		fShaderStream << fShaderFile.rdbuf();
		// close file handlers
		vShaderFile.close();
		fShaderFile.close();
		// convert stream into string
		vertexCode = vShaderStream.str();
		fragmentCode = fShaderStream.str();
	}
	catch (std::ifstream::failure& e)
	{
   
   
		assert(false);
	}
	const char* vShaderCode = vertexCode.c_str();
	const char* fShaderCode = fragmentCode.c_str();
	// 2. compile shaders
	unsigned int vertex, fragment;
	// vertex shader
	vertex = glCreateShader(GL_VERTEX_SHADER);
	glShaderSource(vertex, 1, &vShaderCode, NULL);
	glCompileShader(vertex);
	checkCompileErrors(vertex, "VERTEX");
	// fragment Shader
	fragment = glCreateShader(GL_FRAGMENT_SHADER);
	glShaderSource(fragment, 1, &fShaderCode, NULL);
	glCompileShader(fragment);
	checkCompileErrors(fragment, "FRAGMENT");
	// shader Program
	ID = glCreateProgram();
	glAttachShader(ID, vertex);
	glAttachShader(ID, fragment);
	glLinkProgram(ID);
	checkCompileErrors(ID, "PROGRAM");
	// delete the shaders as they're linked into our program now and no longer necessary
	glDeleteShader(vertex);
	glDeleteShader(fragment);
}

// utility uniform functions
void GiShaderProgram::setBool(const std::string& name, bool value) const
{
   
   
	glUniform1i(glGetUniformLocation(ID, name.c_str()), (int)value);
	CheckGLError();
}

void GiShaderProgram::setInt(const std::string& name, int value) const
{
   
   
	glUniform1i(glGetUniformLocation(ID, name.c_str()), value);
	CheckGLError();
}

void GiShaderProgram::setFloat(const std::string& name, float value) const
{
   
   
	glUniform1f(glGetUniformLocation(ID, name.c_str()), value);
	CheckGLError();
}

void GiShaderProgram::setMat4d(const std::string& name, double* pMat) const
{
   
   
	float pData[16];
	for (int i = 0; i < 16; i++)
		pData[i] = (float)pMat[i];
	glUniformMatrix4fv(glGetUniformLocation(ID, name.c_str()), 1, GL_FALSE, pData);
	CheckGLError();
}

void GiShaderProgram::setMat4f(const std::string& name, float* pMat) const
{
   
   
	glUniformMatrix4fv(glGetUniformLocation(ID, name.c_str()), 1, GL_FALSE, pMat);
	CheckGLError();
}

void GiShaderProgram::setVec4f(const std::string& name, float* pvec) const
{
   
   
	glUniform4fv(glGetUniformLocation(ID, name.c_str()), 1, pvec);
	CheckGLError();
}

void GiShaderProgram::setVec3f(const std::string& name, float* pvec) const
{
   
   
	glUniform3fv(glGetUniformLocation(ID, name.c_str()), 1, pvec);
	CheckGLError();
}

void GiShaderProgram::setVec3f(const std::string& name, float para1, float para2, float para3) const
{
   
   
	float pPts[3] = {
   
    para1,para2,para3 };
	glUniform3fv(glGetUniformLocation(ID, name.c_str()), 1, pPts);
	CheckGLError();
}

void GiShaderProgram::checkCompileErrors(unsigned int shader, std::string type)
{
   
   
	int success;
	char infoLog[1024];
	if (type != "PROGRAM")
	{
   
   
		glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
		if (!success)
		{
   
   
			glGetShaderInfoLog(shader, 1024, NULL, infoLog);
			std::cout << infoLog << std::endl;
			assert(false);
		}
	}
	else
	{
   
   
		glGetProgramiv(shader, GL_LINK_STATUS, &success);
		if (!success)
		{
   
   
			glGetProgramInfoLog(shader, 1024, NULL, infoLog);
			std::cout << infoLog << std::endl;
			assert(false);
		}
	}
}

GiVAO::GiVAO()
{
   
   
	ID = 0;
}

GiVAO::GiVAO(double* pPts, size_t iNum, int ipara1, int ipara2, int ipara3)
{
   
   
	glGenVertexArrays(1, &ID);
	glGenBuffers(1, &iVBO);
	SetPts(pPts, iNum, ipara1, ipara2, ipara3);
}

GiVAO::GiVAO(float* pPts, size_t iNum, int ipara1, int ipara2, int ipara3)
{
   
   
	glGenVertexArrays(1, &ID);
	glGenBuffers(1, &iVBO);
	SetPts(pPts, iNum, ipara1, ipara2, ipara3);
}

GiVAO::~GiVAO()
{
   
   
	if (ID != 0)
	{
   
   
		glDeleteBuffers(1, &iVBO);
		glDeleteVertexArrays(1, &ID);
		CheckGLError();
		ID = 0;
	}
}

void GiVAO::SetPts(float* pPts, size_t iNum, int ipara1, int ipara2, int ipara3)
{
   
   
	if (ID == 0)
	{
   
   
		glGenVertexArrays(1, &ID);
		glGenBuffers(1, &iVBO);
	}

	glBindVertexArray(ID);
	glBindBuffer(GL_ARRAY_BUFFER, iVBO);
	glBufferData(GL_ARRAY_BUFFER, sizeof(float) * iNum, pPts, GL_STATIC_DRAW);
	CheckGLError();
	if (ipara1 > 0)
	{
   
   
		glEnableVertexAttribArray(0);
		glVertexAttribPointer(0, ipara1, GL_FLOAT, GL_FALSE, (ipara1 + ipara2 + ipara3) * sizeof(float), (void*)0);
	}
	if (ipara2 > 0)
	{
   
   
		glEnableVertexAttribArray(1);
		glVertexAttribPointer(1, ipara2, GL_FLOAT, GL_FALSE, (ipara1 + ipara2 + ipara3) * sizeof(float), (void*)(ipara1 * sizeof(float)));
	}
	if (ipara3 > 0)
	{
   
   
		glEnableVertexAttribArray(2);
		glVertexAttribPointer(2, ipara3, GL_FLOAT, GL_FALSE, (ipara1 + ipara2 + ipara3) * sizeof(float), (void*)((ipara1 + ipara2) * sizeof(float)));
	}

	glBindVertexArray(0);
}

void GiVAO::SetPts(double* pPts, size_t iNum, int ipara1, int ipara2, int ipara3)
{
   
   
	if (ID == 0)
	{
   
   
		glGenVertexArrays(1, &ID);
		glGenBuffers(1, &iVBO);
	}

	glBindVertexArray(ID);
	glBindBuffer(GL_ARRAY_BUFFER, iVBO);
	glBufferData(GL_ARRAY_BUFFER, sizeof(double) * iNum, pPts, GL_STATIC_DRAW);
	if (ipara1 > 0)
	{
   
   
		glEnableVertexAttribArray(0);
		glVertexAttribPointer(0, ipara1, GL_DOUBLE, GL_FALSE, (ipara1 + ipara2 + ipara3) * sizeof(double), (void*)0);
	}
	if (ipara2 > 0)
	{
   
   
		glEnableVertexAttribArray(1);
		glVertexAttribPointer(1, ipara2, GL_DOUBLE, GL_FALSE, (ipara1 + ipara2 + ipara3) * sizeof(double), (void*)(ipara1 * sizeof(double)));
	}
	if (ipara3 > 0)
	{
   
   
		glEnableVertexAttribArray(2);
		glVertexAttribPointer(2, ipara3, GL_DOUBL
最低0.47元/天 解锁文章

200万优质内容无限畅学
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值