【计算机图形学-11】OpenGL程序实例分析4——Phong着色

最新推荐文章于 2023-01-30 13:05:50 发布
最新推荐文章于 2023-01-30 13:05:50 发布
阅读量754 收藏 5
点赞数 2
分类专栏： 基于OpenGL的计算机图形学
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_44026604/article/details/112252821
版权

本小节实现Phong着色。Phong着色的核心是片元着色器的设置，如果将片元着色器的设置搬到顶点着色器中，则变成光滑着色。

TriMesh.cpp：

#include "TriMesh.h"


// 一些基础颜色
const vec3 basic_colors[8] = {
	vec3(1.0, 1.0, 1.0),	// White
	vec3(1.0, 1.0, 0.0),	// Yellow
	vec3(0.0, 1.0, 0.0),	// Green
	vec3(0.0, 1.0, 1.0),	// Cyan
	vec3(1.0, 0.0, 1.0),	// Magenta
	vec3(1.0, 0.0, 0.0),	// Red
	vec3(0.0, 0.0, 0.0),	// Black
	vec3(0.0, 0.0, 1.0)		// Blue
};

// 立方体的各个点
const vec3 cube_vertices[8] = {
	vec3(-0.5, -0.5, -0.5),
	vec3(0.5, -0.5, -0.5),
	vec3(-0.5,  0.5, -0.5),
	vec3(0.5,  0.5, -0.5),
	vec3(-0.5, -0.5,  0.5),
	vec3(0.5, -0.5,  0.5),
	vec3(-0.5,  0.5,  0.5),
	vec3(0.5,  0.5,  0.5)
};

// 三角形的点
const vec3 triangle_vertices[3] = {
	vec3(-0.5, -0.5, 0.0),
	vec3(0.5, -0.5, 0.0),
	vec3(0.0, 0.5, 0.0)
};

// 正方形平面
const vec3 square_vertices[4] = {
	vec3(-0.5, -0.5, 0.0),
	vec3(0.5, -0.5, 0.0),
	vec3(0.5, 0.5, 0.0),
	vec3(-0.5, 0.5, 0.0),
};


TriMesh::TriMesh()
{
}

TriMesh::~TriMesh()
{
}

std::vector<vec3> TriMesh::getVertexPositions()
{
	return vertex_positions;
}

std::vector<vec3> TriMesh::getVertexColors()
{
	return vertex_colors;
}

std::vector<vec3> TriMesh::getVertexNormals()
{
	return vertex_normals;
}

std::vector<vec3i> TriMesh::getFaces()
{
	return faces;
}


std::vector<vec3> TriMesh::getPoints()
{
	return points;
}

std::vector<vec3> TriMesh::getColors()
{
	return colors;
}

std::vector<vec3> TriMesh::getNormals()
{
	return normals;
}


void TriMesh::computeTriangleNormals()
{
	// 这里的resize函数会给face_normals分配一个和faces一样大的空间
	face_normals.resize(faces.size());
	for (size_t i = 0; i < faces.size(); i++) {
		auto& face = faces[i];
		// 计算每个面片的法向量并归一化
		vec3 norm;		
		face_normals[i] = cross((vertex_positions[face.y]- vertex_positions[face.x]), (vertex_positions[face.z] - vertex_positions[face.x]));
		face_normals[i] = normalize(face_normals[i]);
		// face_normals[i] = norm;
	}
}

void TriMesh::computeVertexNormals()
{
	// 计算面片的法向量
	if (face_normals.size() == 0 && faces.size() > 0) {
		computeTriangleNormals();
	}
	
	// 这里的resize函数会给vertex_normals分配一个和vertex_positions一样大的空间
	// 并初始化法向量为0
	vertex_normals.resize(vertex_positions.size(), vec3(0, 0, 0));
	// 求法向量均值
	for (size_t i = 0; i < faces.size(); i++) {
		auto& face = faces[i];
		vertex_normals[face.x] += face_normals[i];
		vertex_normals[face.y] += face_normals[i];
		vertex_normals[face.z] += face_normals[i];
	}
	// 对累加的法向量并归一化
	for (size_t i = 0; i < vertex_normals.size(); i++) {
		vertex_normals[i] = normalize(vertex_normals[i] / length(vertex_normals[i]));
	}
}


vec3 TriMesh::getTranslation()
{
	return translation;
}

vec3 TriMesh::getRotation()
{
	return rotation;
}

vec3 TriMesh::getScale()
{
	return scale;
}

mat4 TriMesh::getModelMatrix()
{
	return Translate( getTranslation())*
		RotateZ( getRotation()[2])*
		RotateY( getRotation()[1])*
		RotateX( getRotation()[0])*
		Scale( getScale() );
}

void TriMesh::setTranslation(vec3 translation)
{
	this->translation = translation;
}

void TriMesh::setRotation(vec3 rotation)
{
	this->rotation= rotation;
}

void TriMesh::setScale(vec3 scale)
{
	this->scale = scale;
}

vec4 TriMesh::getAmbient() { return ambient; };
vec4 TriMesh::getDiffuse() { return diffuse; };
vec4 TriMesh::getSpecular() { return specular; };
float TriMesh::getShininess() { return shininess; };

void TriMesh::setAmbient(vec4 _ambient) { ambient = _ambient; };
void TriMesh::setDiffuse(vec4 _diffuse) { diffuse = _diffuse; };
void TriMesh::setSpecular(vec4 _specular) { specular = _specular; };
void TriMesh::setShininess(float _shininess) { shininess = _shininess; };

void TriMesh::cleanData() {
	vertex_positions.clear();
	vertex_colors.clear();
	vertex_normals.clear();
	
	faces.clear();
	face_normals.clear();

	points.clear();
	colors.clear();
	normals.clear();
}

void TriMesh::storeFacesPoints() {
	// 计算法向量
	if (vertex_normals.size() == 0)
		computeVertexNormals();
	
	// 根据每个三角面片的顶点下标存储要传入GPU的数据
	for (int i = 0; i < faces.size(); i++)
	{
		// 坐标
		points.push_back(vertex_positions[faces[i].x]);
		points.push_back(vertex_positions[faces[i].y]);
		points.push_back(vertex_positions[faces[i].z]);
		// 颜色
		colors.push_back(vertex_colors[faces[i].x]);
		colors.push_back(vertex_colors[faces[i].y]);
		colors.push_back(vertex_colors[faces[i].z]);
		// 法向量
		if (vertex_normals.size() != 0) {
			normals.push_back(vertex_normals[faces[i].x]);
			normals.push_back(vertex_normals[faces[i].y]);
			normals.push_back(vertex_normals[faces[i].z]);
		}
	}
}

// 立方体生成12个三角形的顶点索引
void TriMesh::generateCube() {
	// 创建顶点前要先把那些vector清空
	cleanData();

	// 存储立方体的各个面信息
	for (int i = 0; i < 8; i++)
	{
		vertex_positions.push_back(cube_vertices[i]);
		vertex_colors.push_back(basic_colors[i]);
	}

	// 每个三角面片的顶点下标
	faces.push_back(vec3i(0, 1, 3));
	faces.push_back(vec3i(0, 3, 2));
	faces.push_back(vec3i(1, 4, 5));
	faces.push_back(vec3i(1, 0, 4));
	faces.push_back(vec3i(4, 0, 2));
	faces.push_back(vec3i(4, 2, 6));
	faces.push_back(vec3i(5, 6, 4));
	faces.push_back(vec3i(5, 7, 6));
	faces.push_back(vec3i(2, 6, 7));
	faces.push_back(vec3i(2, 7, 3));
	faces.push_back(vec3i(1, 5, 7));
	faces.push_back(vec3i(1, 7, 3));

	storeFacesPoints();
}

void TriMesh::generateTriangle(vec3 color)
{
	// 创建顶点前要先把那些vector清空
	cleanData();

	for (int i = 0; i < 3; i++)
	{
		vertex_positions.push_back(triangle_vertices[i]);
		vertex_colors.push_back(color);
	}

	// 每个三角面片的顶点下标
	faces.push_back(vec3i(0, 1, 2));

	storeFacesPoints();
}


void TriMesh::generateSquare(vec3 color)
{
	// 创建顶点前要先把那些vector清空
	cleanData();

	for (int i = 0; i < 4; i++)
	{
		vertex_positions.push_back(square_vertices[i]);
		vertex_colors.push_back(color);
	}

	// 每个三角面片的顶点下标
	faces.push_back(vec3i(0, 1, 2));
	faces.push_back(vec3i(0, 2, 3));
	storeFacesPoints();
}

void TriMesh::readOff(const std::string& filename)
{
    // fin打开文件读取文件信息
    if (filename.empty())
    {
        return;
    }
    std::ifstream fin;
    fin.open(filename);
    if (!fin)
    {
        printf("File on error\n");
        return;
    }
    else
    {
        printf("File open success\n");

		cleanData();

		int nVertices, nFaces, nEdges;

        // 读取OFF字符串
        std::string str;
        fin >> str;
        // 读取文件中顶点数、面片数、边数
        fin >> nVertices >> nFaces >> nEdges;
        // 根据顶点数，循环读取每个顶点坐标
        for (int i = 0; i < nVertices; i++)
        {
            vec3 tmp_node;
            fin >> tmp_node.x >> tmp_node.y >> tmp_node.z;
            vertex_positions.push_back(tmp_node);
			vertex_colors.push_back(tmp_node);
        }
        // 根据面片数，循环读取每个面片信息，并用构建的vec3i结构体保存
        for (int i = 0; i < nFaces; i++)
        {
            int num, a, b, c;
            // num记录此面片由几个顶点构成，a、b、c为构成该面片顶点序号
            fin >> num >> a >> b >> c;
            faces.push_back(vec3i(a, b, c));
        }
    }
    fin.close();

    storeFacesPoints();
};


// Light
mat4 Light::getShadowProjectionMatrix() {
	// 这里只实现了Y=0平面上的阴影投影矩阵
	float lx, ly, lz;

	mat4 modelMatrix = this->getModelMatrix();
	vec4 light_position = modelMatrix * this->translation;
	
	lx = light_position[0];
	ly = light_position[1];
	lz = light_position[2];
	
	return mat4(
		-ly, 0.0, 0.0, 0.0,
		lx, 0.0, lz, 1.0,
		0.0, 0.0, -ly, 0.0,
		0.0, 0.0, 0.0, -ly
	);
}

main.cpp

#include "Angel.h"
#include "mat.h"
#include "vec.h"
#include "TriMesh.h"
#include "Camera.h"
#include <iostream>

#include <vector>
#include <string>
#include <algorithm>


using namespace std;
int WIDTH = 600;
int HEIGHT = 600;

int mainWindow;

struct openGLObject
{
	// 顶点数组对象
	GLuint vao;
	// 顶点缓存对象
	GLuint vbo;

	// 着色器程序
	GLuint program;
	// 着色器文件
	std::string vshader;
	std::string fshader;
	// 着色器变量
	GLuint pLocation;
	GLuint cLocation;
	GLuint nLocation;

	// 投影变换变量
	GLuint modelLocation;
	GLuint viewLocation;
	GLuint projectionLocation;

	// 阴影变量
	GLuint shadowLocation;
};


openGLObject mesh_object;

Light* light = new Light();

TriMesh* mesh = new TriMesh();

Camera* camera = new Camera();

void bindObjectAndData(TriMesh* mesh, openGLObject& object, const std::string &vshader, const std::string &fshader) {

	// 创建顶点数组对象
	#ifdef __APPLE__	// for MacOS
		glGenVertexArraysAPPLE(1, &object.vao);		// 分配1个顶点数组对象
		glBindVertexArrayAPPLE(object.vao);		// 绑定顶点数组对象
	#else				// for Windows
		glGenVertexArrays(1, &object.vao);  	// 分配1个顶点数组对象
		glBindVertexArray(object.vao);  	// 绑定顶点数组对象
	#endif

	// 创建并初始化顶点缓存对象
	glGenBuffers(1, &object.vbo);
	glBindBuffer(GL_ARRAY_BUFFER, object.vbo);
	glBufferData(GL_ARRAY_BUFFER, 
		( mesh->getPoints().size() + mesh->getColors().size() + mesh->getNormals().size() ) * sizeof(vec3),
		NULL, 
		GL_STATIC_DRAW);

	glBufferSubData(GL_ARRAY_BUFFER, 0, mesh->getPoints().size() * sizeof(vec3), &mesh->getPoints()[0]);
	glBufferSubData(GL_ARRAY_BUFFER, mesh->getPoints().size() * sizeof(vec3), mesh->getColors().size() * sizeof(vec3), &mesh->getColors()[0]);
	glBufferSubData(GL_ARRAY_BUFFER, (mesh->getPoints().size() + mesh->getColors().size()) * sizeof(vec3), mesh->getNormals().size() * sizeof(vec3), &mesh->getNormals()[0]);

	object.vshader = vshader;
	object.fshader = fshader;
	object.program = InitShader(object.vshader.c_str(), object.fshader.c_str());

	// 从顶点着色器中初始化顶点的坐标
	object.pLocation = glGetAttribLocation(object.program, "vPosition");
	glEnableVertexAttribArray(object.pLocation);
	glVertexAttribPointer(object.pLocation, 3, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(0));

	// 从顶点着色器中初始化顶点的颜色
	object.cLocation = glGetAttribLocation(object.program, "vColor");
	glEnableVertexAttribArray(object.cLocation);
	glVertexAttribPointer(object.cLocation, 3, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET(mesh->getPoints().size() * sizeof(vec3)));

	// 从顶点着色器中初始化顶点的法向量
	object.nLocation = glGetAttribLocation(object.program, "vNormal");
	glEnableVertexAttribArray(object.nLocation);
	glVertexAttribPointer(object.nLocation, 3, GL_FLOAT, GL_FALSE, 0, BUFFER_OFFSET((mesh->getPoints().size() + mesh->getColors().size()) * sizeof(vec3)));
	
	// 获得矩阵位置
	object.modelLocation = glGetUniformLocation(object.program, "model");
	object.viewLocation = glGetUniformLocation(object.program, "view");
	object.projectionLocation = glGetUniformLocation(object.program, "projection");
	object.shadowLocation = glGetUniformLocation(object.program, "isShadow");
}

void bindLightAndMaterial(TriMesh* mesh, openGLObject& object, Light* light, Camera* camera) {

	// 传递相机的位置
	glUniform3fv( glGetUniformLocation(object.program, "eye_position"), 1, vec3(camera->eye[0], camera->eye[1], camera->eye[2]) );

	// 传递物体的材质
	vec4 meshAmbient = mesh->getAmbient();
	vec4 meshDiffuse = mesh->getDiffuse();
	vec4 meshSpecular = mesh->getSpecular();
	float meshShininess = mesh->getShininess();
	glUniform4fv(glGetUniformLocation(object.program, "material.ambient"), 1, meshAmbient);
	glUniform4fv(glGetUniformLocation(object.program, "material.diffuse"), 1, meshDiffuse);
	glUniform4fv(glGetUniformLocation(object.program, "material.specular"), 1, meshSpecular);
	glUniform1f(glGetUniformLocation(object.program, "material.shininess"), meshShininess);

	// 传递光源信息
	vec4 lightAmbient = light->getAmbient();
	vec4 lightDiffuse = light->getDiffuse();
	vec4 lightSpecular = light->getSpecular();
	vec3 lightPosition = light->getTranslation();

	glUniform4fv(glGetUniformLocation(object.program, "light.ambient"), 1, lightAmbient);
	glUniform4fv(glGetUniformLocation(object.program, "light.diffuse"), 1, lightDiffuse);
	glUniform4fv(glGetUniformLocation(object.program, "light.specular"), 1, lightSpecular);
	glUniform3fv(glGetUniformLocation(object.program, "light.position"), 1, lightPosition);

}


void init()
{
	std::string vshader, fshader;
	// 读取着色器并使用
	#ifdef __APPLE__	// for MacOS
		vshader = "shaders/vshader_mac.glsl";
		fshader = "shaders/fshader_mac.glsl";
	#else				// for Windows
		vshader = "shaders/vshader_win.glsl";
		fshader = "shaders/fshader_win.glsl";
	#endif

	// 设置光源位置
	light->setTranslation(vec3(0.0, 0.0, 2.0));
	light->setAmbient(vec4(1.0, 1.0, 1.0, 1.0)); // 环境光
	light->setDiffuse(vec4(1.0, 1.0, 1.0, 1.0)); // 漫反射
	light->setSpecular(vec4(1.0, 1.0, 1.0, 1.0)); // 镜面反射

	// 设置物体的旋转位移
	mesh->setTranslation(vec3(0.0, 0.0, 0.0));
	mesh->setRotation(vec3(0.0, 0.0, 0.0));
	mesh->setScale(vec3(1.0, 1.0, 1.0));

	// 设置材质
	mesh->setAmbient(vec4(0.2, 0.2, 0.2, 1.0)); // 环境光
	mesh->setDiffuse(vec4(0.7, 0.7, 0.7, 1.0)); // 漫反射
	mesh->setSpecular(vec4(0.2, 0.2, 0.2, 1.0)); // 镜面反射
	mesh->setShininess(1.0); //高光系数
	
	// 将物体的顶点数据传递
	bindObjectAndData(mesh, mesh_object, vshader, fshader);

	glClearColor(0.0, 0.0, 0.0, 0.0);
}



void display()
{
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

	// 相机矩阵计算
	camera->updateCamera();
	camera->viewMatrix = camera->getViewMatrix();
	camera->projMatrix = camera->getProjectionMatrix(false);

	#ifdef __APPLE__	// for MacOS
		glBindVertexArrayAPPLE(mesh_object.vao);
	#else
		glBindVertexArray(mesh_object.vao);
	#endif
	glUseProgram(mesh_object.program);

	// 物体的变换矩阵
	mat4 modelMatrix = mesh->getModelMatrix();

	// 传递矩阵
	glUniformMatrix4fv(mesh_object.modelLocation, 1, GL_TRUE, &modelMatrix[0][0]);
	glUniformMatrix4fv(mesh_object.viewLocation, 1, GL_TRUE, &camera->viewMatrix[0][0]);
	glUniformMatrix4fv(mesh_object.projectionLocation, 1, GL_TRUE, &camera->projMatrix[0][0]);
	// 将着色器变量 isShadow 设置为0，表示正常绘制的颜色，如果是1着表示阴影
	glUniform1i(mesh_object.shadowLocation, 0);

	// 将材质和光源数据传递给着色器
	bindLightAndMaterial(mesh, mesh_object, light, camera);
	// 绘制
	glDrawArrays(GL_TRIANGLES, 0, mesh->getPoints().size());

	glutSwapBuffers();
}


void printHelp()
{
	std::cout << "================================================" << std::endl;
	std::cout << "Use mouse to controll the light position (drag)." << std::endl;
	std::cout << "================================================" << std::endl << std::endl;

	std::cout << "Keyboard Usage" << std::endl;
	std::cout <<
		"[Window]" << std::endl <<
		"ESC:		Exit" << std::endl <<
		"h:		Print help message" << std::endl <<
		std::endl <<
		"[Model]" << std::endl <<
		"-:		Reset material parameters" << std::endl <<
		"1/2/3/!/@/#:	Change ambient parameters" << std::endl <<
		"4/5/6/$/%/^:	(TODO) Change diffuse parameters" << std::endl <<
		"7/8/9/&/*/(:	(TODO) Change specular parameters" << std::endl <<
		"0/):		(TODO) Change shininess parameters" << std::endl <<
		std::endl <<
		"q:		Load sphere model" << std::endl << 
		"a:		Load Pikachu model" << std::endl << 
		"w:		Load Squirtle model" << std::endl << 
		"s:		Load sphere_coarse model" << std::endl << 
		std::endl <<
		"[Camera]" << std::endl <<
		"SPACE:		Reset camera parameters" << std::endl <<
		"u/U:		Increase/Decrease the rotate angle" << std::endl <<
		"i/I:		Increase/Decrease the up angle" << std::endl <<
		"o/O:		Increase/Decrease the camera radius" << std::endl << std::endl;

}

// 鼠标响应函数
void mouse(int x, int y)
{
	// 用鼠标控制光源的位置lightPos，以实时更新光照效果
	// 窗口坐标系与图像坐标系转换
	float half_winx = WIDTH / 2.0;
	float half_winy = HEIGHT / 2.0;
	float lx = float(x - half_winx) / half_winx;
	float ly = float(HEIGHT - y - half_winy) / half_winy;
	
	vec3 pos = light->getTranslation();
	
	pos.x = lx;
	pos.y = ly;
	light->setTranslation(pos);
}

void mouseWheel(int button, int dir, int x, int y)
{
	vec3 pos = light->getTranslation();

	if (dir > 0)
	{
		pos.z += 0.1;
		// std::cout << "far from to light\n";
	}
	else
	{
		pos.z -= 0.1;
		// std::cout << "close to light\n";
	}
	light->setTranslation(pos);
}

// 键盘响应函数
void keyboard(unsigned char key, int x, int y)
{
	float tmp;
	vec4 ambient;
	switch (key)
	{
		// ESC键退出游戏
	case 033: exit(EXIT_SUCCESS); break;
	case 'h': printHelp(); break;

	case 'q':
		std::cout << "read sphere.off" << std::endl;
		mesh = new TriMesh();
		mesh->readOff("./assert/sphere.off");
		init();
		break;
	case 'a':
		std::cout << "read Pikachu.off" << std::endl;
		mesh = new TriMesh();
		mesh->readOff("./assert/Pikachu.off");
		init();
		break;
	case 'w':
		std::cout << "read Squirtle.off" << std::endl;
		mesh = new TriMesh();
		mesh->readOff("./assert/Squirtle.off");
		init();
		break;
	case 's':
		std::cout << "read sphere_coarse.off" << std::endl;
		mesh = new TriMesh();
		mesh->readOff("./assert/sphere_coarse.off");
		init();
		break;
	case '1': 
		ambient = mesh->getAmbient();
		tmp = ambient.x;
		ambient.x = std::min(tmp + 0.1, 1.0); 
		mesh->setAmbient(ambient);
		break;
	case '2':
		ambient = mesh->getAmbient();
		tmp = ambient.y;
		ambient.y = std::min(tmp + 0.1, 1.0);
		mesh->setAmbient(ambient);
		break;
	case '3':
		ambient = mesh->getAmbient();
		tmp = ambient.z;
		ambient.z = std::min(tmp + 0.1, 1.0);
		mesh->setAmbient(ambient);
		break;
		
	case '!':
		ambient = mesh->getAmbient();
		tmp = ambient.x;
		ambient.x = std::max(tmp - 0.1, 0.0);
		mesh->setAmbient(ambient);
		break;
	case '@':
		ambient = mesh->getAmbient();
		tmp = ambient.y;
		ambient.y = std::max(tmp - 0.1, 0.0);
		mesh->setAmbient(ambient);
		break; 
	case '#':
		ambient = mesh->getAmbient();
		tmp = ambient.z;
		ambient.z = std::max(tmp - 0.1, 0.0);
		mesh->setAmbient(ambient);
		break;

	// 控制调整材质，以实时更新光照效果

	case '-':
		mesh->setAmbient(vec4(0.2, 0.2, 0.2, 1.0));
		mesh->setDiffuse(vec4(0.7, 0.7, 0.7, 1.0));
		mesh->setSpecular(vec4(0.2, 0.2, 0.2, 1.0));
		mesh->setShininess(1.0);
		break;
	case '=':
		std::cout << "ambient: " << mesh->getAmbient() << std::endl;
		std::cout << "diffuse: " << mesh->getDiffuse() << std::endl;
		std::cout << "specular: " << mesh->getSpecular() << std::endl;
		std::cout << "shininess: " << mesh->getShininess() << std::endl;
		break;
	case ' ':
		cin >> a >> b >> c;
		break;

	// 通过按键改变相机和投影的参数
	default:
		camera->keyboard(key, x, y);
		break;

	}
	glutPostRedisplay();

}


void idle(void)
{
	glutPostRedisplay();
}

// 重新设置窗口
void reshape(GLsizei w, GLsizei h)
{
	glViewport(0, 0, w, h);
}

void cleanData() {
	mesh->cleanData();
	
	delete camera;
	camera = NULL;

	// 释放内存
	delete mesh;
	mesh = NULL;

	// 删除绑定的对象
	#ifdef __APPLE__
		glDeleteVertexArraysAPPLE(1, &mesh_object.vao);
	#else
		glDeleteVertexArrays(1, &mesh_object.vao);
	#endif
	glDeleteBuffers(1, &mesh_object.vbo);
	glDeleteProgram(mesh_object.program);

}

int main(int argc, char **argv)
{
	glutInit(&argc, argv);
	// 窗口支持双重缓冲、深度测试、超采样
	glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE | GLUT_DEPTH | GLUT_MULTISAMPLE);
	glutInitWindowPosition(100, 100);
	glutInitWindowSize(WIDTH, HEIGHT);
	mainWindow = glutCreateWindow("Phong-Vertex");
	 
	#ifdef __APPLE__
	#else
		glewExperimental = GL_TRUE;
		glewInit();
	#endif

	mesh->readOff("./assert/sphere.off");
	// Init mesh, shaders, buffer
	init();

	// bind callbacks
	glutDisplayFunc(display);
	glutReshapeFunc(reshape);
	glutKeyboardFunc(keyboard);
	glutMotionFunc(mouse);
	// glutMouseWheelFunc(mouseWheel);
	glutIdleFunc(idle);

	// 输出帮助信息
	printHelp();
	// 启用深度测试
	glEnable(GL_DEPTH_TEST);

	glutMainLoop();


	cleanData();


	return 0;
}

顶点着色器：

#version 330 core

in vec3 vPosition;
in vec3 vColor;
in vec3 vNormal;

// 模型变换矩阵、相机观察矩阵、投影矩阵
uniform mat4 model;
uniform mat4 view;
uniform mat4 projection;

out vec3 position;
out vec3 normal;

void main() 
{
	vec4 v1 = model * vec4(vPosition, 1.0);  
	// 由于model矩阵有可能为阴影矩阵，为了得到正确位置，我们需要做一次透视除法
	vec4 v2 = vec4(v1.xyz / v1.w, 1.0);
	// 考虑相机和投影
	vec4 v3 = projection* view * v2;
	gl_Position = v3;

    position = vec3(v2.xyz);
    normal = vec3( model * vec4(vNormal, 0.0) );
}

片元着色器：

#version 330 core


// 给光源数据一个结构体
struct Light{
	vec4 ambient;
	vec4 diffuse;
	vec4 specular;
	vec3 position;
};

// 给物体材质数据一个结构体
struct Material{
	vec4 ambient;
	vec4 diffuse;
	vec4 specular;

	float shininess;
};

in vec3 position;
in vec3 normal;

// 相机坐标
uniform vec3 eye_position;
// 光源
uniform Light light;
// 物体材质
uniform Material material;

uniform int isShadow;

out vec4 fColor;

void main()
{
	if (isShadow == 1) {
		fColor = vec4(0.0, 0.0, 0.0, 1.0);
	}
	else {
			
		// 计算四个归一化的向量 N,V,L,R(或半角向量H)
		vec3 N=normalize(normal);
		vec3 V=normalize(eye_position-position);
		vec3 L=normalize(light.position-position);
		vec3 R=reflect(-L,N);

		// 环境光分量I_a
		vec4 I_a = light.ambient * material.ambient;

		// 计算系数和漫反射分量I_d
		float diffuse_dot = max(dot(L, N), 0);
		vec4 I_d = diffuse_dot *  light.diffuse * material.diffuse;

		// 计算系数和镜面反射分量I_s
		float specular_dot_pow = pow(max(dot(R, V), 0), material.shininess);
		vec4 I_s = specular_dot_pow * light.specular * material.specular;

		// 注意如果光源在背面则去除高光
		if( dot(L, N) < 0.0 ) {
		    I_s = vec4(0.0, 0.0, 0.0, 1.0);
		} 

		fColor = I_a + I_d + I_s;
		fColor.a = 1.0;
	}
}
AndyZzz~
关注
  • 2
    点赞
  • 踩
  • 5
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
计算机图形学-金属球绘制（phong）
03-22
1.MFC 2.opengl 3.绘制一个phong着色的球体 4.可以旋转
计算机图形学 | 实验八：Phong模型
ProgramNovice的博客
05-19 748
计算机图形学 | 实验八：Phong模型
计算机图形学 1 —— 颜色模型图像基本知识，Phong光照模型
wdw18668109050的博客
11-23 1657
颜色模型图像基本知识，Phong光照模型
【OpenGL学习】OpenGL实现 基于Phong模型的基础光照
miyazono_的博客
01-30 1052
OpenGL实现 基于Phong模型的基础光照，推导了法线变换使用的逆转置矩阵
openGL中Phong 着色
aoxuestudy的专栏
01-31 4032
定义了环面、光照和材质特性。接着将环面顶点以及相关法向量读入缓冲区，展示了Phong 着色应用在比较复杂的外部软件生成模型
Blinn-Phong光照模型解析及其实现
weixin_43757333的博客
04-26 5571
本文使用OpenGL，实现了Blinn-Phong光照模型
计算机图形学基础-pdf.zip
02-21
1.1计算机图形学及其相关概念 1.2计算机图形学的发展 1.2.1计算机图形学学科的发展 1.2.2图形硬件设备的发展 1.2.3图形软件的发展 1.3计算机图形学的应用 1.3.1计算机辅助设计与制造 1.3.2计算机辅助...
OpenGL-Phong.zip
05-19
在Visual Studio 2015上基于OpenGL实现Phong模型。 中间的立方体是被照射的对象，有一个定向光源，六个点光源和一个聚光的光源。 我们这里设置了键盘响应事件，按1开启定向光，2~7开启点光源，8开启聚光效果。
Shading:计算机图形类的 Phong 和 Blinn-Phong 着色的实现
06-12
'ant' 应该足以构建和运行程序，前提是您安装了 ant。 在 OS X 上测试。 有关如何操作模型的精确说明，请参阅 Controls.txt。 该项目具有三种不同的照明模型： 朗伯漫反射防高光布林镜面它还包括一个额外的线框着色...
案例51-球面Phong明暗处理算法_代码_vs6.0_计算机图形学_
10-02
上传受限，所以只能分开上传，实在抱歉。该文档为计算机图形学案例51-球面Phong明暗处理算法
轻松愉快学Shader(2)_Phong着色
08-05
轻松愉快学Shader(2)_Phong着色
【光线追踪系列一】PPM输出；自定义vec3；光线、简单相机及天空采样
qq_35312463的博客
08-29 1574
本次光线追踪从基础开始从新开始，主要参照 Ray Tracing in One Weekend ，具体实现代码框架见 https://github.com/RayTracing/raytracing.github.io/。本文只是主要精炼光追相关理论，具体实现可参照原文。 一、PPM输出 1.1 PPM格式 ppm是一种直接存储RGB颜色值的文件格式，第一行是p3，表示颜色值用ASCII存。第二行是图像的宽和高。接下来是每一行按顺序存放的颜色值。 ，具体实现可参照原文，本人实现效果如下： 二、自定义ve
Phong光照模型及OpenGL实现（二）
yuebaidada的博客
06-25 3651
OpenGL实现 这一篇的主要内容是利用OpenGL实现phong模型，这里为了专注于phong模型，使用最为简单的正方体作为被光照影响的物体，并分别使用点平行光光源、光源以及聚光灯光源测试。 平行光光源 平行光光源一般用于表示极远处的光源，往往可以用来表示日光、月光等光源，由于光源的距离极远，往往可认为所产生的的光是平行且光照强度相等的，即物体每一点所受光照相同，如图1所示（原谅我图画的丑…） ...
OPENGL编程宝典Phong着色
让阳光照进心里
02-01 3519
// DiffuseLight.cpp // OpenGL SuperBible // Demonstrates simple diffuse lighting // Program by Richard S. Wright Jr. #include // OpenGL toolkit #include #include #include #include #include #in
现代OpenGL的介绍 第4章：用Phong着色渲染动态3D场景
tailiangliang的专栏
07-29 1506
原文地址   现代OpenGL的介绍。第4章：用Phong着色渲染动态3D场景 更新2010年7月15日08:06:09 PDT «第3章 | 目录 在这一点上，我们已经看到了OpenGL API最重要的核心部分，并获得了GLSL语言的体面品味。现在是开始锻炼OpenGL并实现一些图形效果的好时机，在我们走过时，引入了新的细微差别和OpenGL和GLSL的特殊功能。在接下来的几章
OpenGL进阶(十二) - 基础着色（Shading）
weixin_34362875的博客
08-17 581
提要 经过前面的关于GLSL基础学习，可以参考OpenGL进阶专栏中的一些文章。 接下来的内容将会非常的有意思，比如全局光照，环境贴图，法线贴图，景深....是不是听着就很棒！想要学习的话，当然需要付出更多的努力！不过一切都是值得的。 今天的内容主要是关于光照的一些基础着色。 在光照模型中，光照主要由三部分组成：环境光（ambient），漫反射...
探究OpenGL光照模型的着色器实现
架构设计
09-27 251
探究OpenGL光照模型的着色器实现 OpenGL的着色器是新一代显卡提供给开发者一个小程序，为的是让开发者对光照、坐标转换以及像素进行一些个性化的处理。OpenGL的着色器有一种专门的语言：GLSL，现在的GLSL应该全面转向Shader Model5，像我这样的初学者还需要花费更长的时间来学习才能基本了解OpenGL的着色器方面的知识。 下面两图展示了OpenGL从固定渲染管线到可...
OpenGL ADSPhong着色
jk823394954的专栏
09-02 729
在上一节ADSGouraud着色模式下，我们看到当小球旋转时，亮光的部分时隐时现的，这是由于三角形之间的不连续造成的。 我们可以用ADSPhong着色模式来解决这种问题，在ADSGouraud着色模式下，顶点着色器传入片段着色器的是每个顶点的颜色值，顶点之间的颜色是通过线性插值计算出来的，这样在小球旋转的情况先就可能产生亮光的部分时隐时现的的情况 ，ADSPhong着色模式中顶点着色器传入到片段
[6.837]A3:OpenG应用和Phong着色模型
qq_32096491的博客
10-22 426
任务概述本次作业中，我们将向场景中添加实时交互预览，同时为之前的光线追踪器增加Phong着色模型。为了达到交互显示，我们将使用OpenGLAPI在显卡上快速渲染三维多边形。我们将能够实时预览场景并且改变视点，接下来用光线追踪器来渲染高质量的图像。许多基础结构在之前的作业中已经构建好，我们只需要向API传递正确的三角形绘制指令或者绘制各种Object3D类的图元。在OpenGL中，API接受所有的透视
计算机图形学openGL大作业
最新发布
05-22
在计算机图形学中，它被广泛用于实现各种3D和2D图形应用程序，例如游戏、建筑可视化、动画等。 OpenGl大作业的实现可以根据不同的需求和难度来设计，以下是一些可能的OpenGl大作业： 1. 游戏开发：实现一个简单的...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值