路径追踪 SAH优化的Bvh

最新推荐文章于 2024-08-28 10:54:55 发布
最新推荐文章于 2024-08-28 10:54:55 发布
阅读量913 收藏 2
点赞数
分类专栏： VC++ 文章标签： 算法 c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/asaqlp/article/details/120404990
版权

BVH 层次包围盒
SAH 优化BVH
BVH具体怎么做

我们加载模型用数组 一个个记录模型的三角形 和材质

光线追踪 判断光线和模型相交时返回命中的三角形 颜色材质
每次判断相交都是 把整个场景三角形 全部遍历 可想而知会很慢

就需要我们优化 把他们按照区域分类开来先判断 光线和区域相交
再判断区域中的三角形，一层层下去避免浪费 这就是Bvh结构

在这里插入图片描述
图片中的兔子就是按照250*250 直线判断相交 ，返回三角形表示命中， 这个点就显示出颜色

for (int i = 0; i < WIDTH; i +=2)
	{
		for (int j = 0; j < HEIGHT; j +=2)
		{
			// 像素坐标转投影平面坐标
			double x = 2.0 * double(j) / double(WIDTH) - 1.0;
			double y = 2.0 * double(HEIGHT - i) / double(HEIGHT) - 1.0;
			// MSAA
			x += (randf() - 0.5f) / double(WIDTH);
			y += (randf() - 0.5f) / double(HEIGHT);

			vec3 coord = vec3(x, y, SCREEN_Z);          // 计算投影平面坐标
			vec3 direction = normalize(coord - EYE);    // 计算光线投射方向
														// 生成光线
			Ray ray;
			ray.startPoint = coord;
			ray.direction = direction;

			vec3 color = vec3(0, 0, 0);

			HitResult res = hitBVH(ray, triangles, root);

			if (res.triangle != NULL) { //判断是否命中  得到三角形既命中模型返回颜色
				color = vec3(0, 0.5, 0);
			}
			buffer[i][j] = RGB(color.x * 255, color.y * 255, color.z * 255);
		}
	}

上面就是一个简单的光线追踪实现，不反射不计算材质也没有材质
完整代码可以使用第一章的框架 复制这份

#include <iostream>
#include <string>
#include <fstream>
#include <vector>
#include <sstream>
#include <iostream>
#include <algorithm>

#include <GL/glew.h>
#include <freeglut.h>
#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp>

#define INF 114514.0


#include<ctime>
#include<mmintrin.h>



// 输出图像分辨率
const int WIDTH = 250;
const int HEIGHT = 250;
GLuint texture;
typedef unsigned int Color;
static  Color buffer[HEIGHT][WIDTH];
int frames; clock_t clocks;

using namespace glm;
vec3 光线命中坐标 = vec3(0, 0, 0);  // 光线命中点
// ----------------------------------------------------------------------------- //

GLuint program;                 // 着色器程序对象
std::vector<vec3> vertices;     // 顶点坐标
std::vector<GLuint> indices;    // 顶点索引
std::vector<vec3> lines;        // 线段端点坐标
vec3 rotateControl(0, 0, 0);    // 旋转参数
vec3 scaleControl(1, 1, 1);     // 缩放参数

								// BVH 树节点
struct BVHNode {
	BVHNode* left = NULL;       // 左右子树索引
	BVHNode* right = NULL;
	int n, index;               // 叶子节点信息               
	vec3 AA, BB;                // 碰撞盒
};

typedef struct Triangle {
	vec3 p1, p2, p3;   // 三点
	vec3 center;       // 中心
	Triangle(vec3 a, vec3 b, vec3 c) {
		p1 = a, p2 = b, p3 = c;
		center = (p1 + p2 + p3) / vec3(3, 3, 3);
	}
} Triangle;
std::vector<Triangle> triangles;

// 按照三角形中心排序 -- 比较函数
bool cmpx(const Triangle& t1, const Triangle& t2) {
	return t1.center.x < t2.center.x;
}
bool cmpy(const Triangle& t1, const Triangle& t2) {
	return t1.center.y < t2.center.y;
}
bool cmpz(const Triangle& t1, const Triangle& t2) {
	return t1.center.z < t2.center.z;
}

// 求交结果
struct HitResult {
	Triangle* triangle = NULL;
	float distance = INF;
	vec3 光线命中点 = vec3(0, 0, 0);  // 光线命中点
	bool 是否命中 = 0;             // 是否命中
};

// 光线
typedef struct Ray {
	vec3 startPoint = vec3(0, 0, 0);    // 起点
	vec3 direction = vec3(0, 0, 0);     // 方向
}Ray;

// ----------------------------------------------------------------------------- //

// 读取文件并且返回一个长字符串表示文件内容
std::string readShaderFile(std::string filepath) {
	std::string res, line;
	std::ifstream fin(filepath);
	if (!fin.is_open())
	{
		std::cout << "文件 " << filepath << " 打开失败" << std::endl;
		exit(-1);
	}
	while (std::getline(fin, line))
	{
		res += line + '\n';
	}
	fin.close();
	return res;
}

// 获取着色器对象
GLuint getShaderProgram(std::string fshader, std::string vshader) {
	// 读取shader源文件
	std::string vSource = readShaderFile(vshader);
	std::string fSource = readShaderFile(fshader);
	const char* vpointer = vSource.c_str();
	const char* fpointer = fSource.c_str();

	// 容错
	GLint success;
	GLchar infoLog[512];

	// 创建并编译顶点着色器
	GLuint vertexShader = glCreateShader(GL_VERTEX_SHADER);
	glShaderSource(vertexShader, 1, (const GLchar**)(&vpointer), NULL);
	glCompileShader(vertexShader);
	glGetShaderiv(vertexShader, GL_COMPILE_STATUS, &success);   // 错误检测
	if (!success)
	{
		glGetShaderInfoLog(vertexShader, 512, NULL, infoLog);
		std::cout << "顶点着色器编译错误\n" << infoLog << std::endl;
		exit(-1);
	}

	// 创建并且编译片段着色器
	GLuint fragmentShader = glCreateShader(GL_FRAGMENT_SHADER);
	glShaderSource(fragmentShader, 1, (const GLchar**)(&fpointer), NULL);
	glCompileShader(fragmentShader);
	glGetShaderiv(fragmentShader, GL_COMPILE_STATUS, &success);   // 错误检测
	if (!success)
	{
		glGetShaderInfoLog(fragmentShader, 512, NULL, infoLog);
		std::cout << "片段着色器编译错误\n" << infoLog << std::endl;
		exit(-1);
	}

	// 链接两个着色器到program对象
	GLuint shaderProgram = glCreateProgram();
	glAttachShader(shaderProgram, vertexShader);
	glAttachShader(shaderProgram, fragmentShader);
	glLinkProgram(shaderProgram);

	// 删除着色器对象
	glDeleteShader(vertexShader);
	glDeleteShader(fragmentShader);

	return shaderProgram;
}

// 读取 obj
void readObj(std::string filepath, std::vector<vec3>& vertices, std::vector<GLuint>& indices) {
	// 打开文件流
	std::ifstream fin(filepath);
	std::string line;
	if (!fin.is_open()) {
		std::cout << "文件 " << filepath << " 打开失败" << std::endl;
		exit(-1);
	}

	// 增量读取
	int offset = vertices.size();

	// 按行读取
	while (std::getline(fin, line)) {
		std::istringstream sin(line);   // 以一行的数据作为 string stream 解析并且读取
		std::string type;
		GLfloat x, y, z;
		int v0, v1, v2;

		// 读取obj文件
		sin >> type;
		if (type == "v") {
			sin >> x >> y >> z;
			vertices.push_back(vec3(x, y, z));
		}
		if (type == "f") {
			sin >> v0 >> v1 >> v2;
			indices.push_back(v0 - 1 + offset);
			indices.push_back(v1 - 1 + offset);
			indices.push_back(v2 - 1 + offset);
		}
	}
}

void addLine(vec3 p1, vec3 p2) {
	lines.push_back(p1);
	lines.push_back(p2);
}

void addBox(BVHNode* root) {
	float x1 = root->AA.x, y1 = root->AA.y, z1 = root->AA.z;
	float x2 = root->BB.x, y2 = root->BB.y, z2 = root->BB.z;
	lines.push_back(vec3(x1, y1, z1)), lines.push_back(vec3(x2, y1, z1));
	lines.push_back(vec3(x1, y1, z1)), lines.push_back(vec3(x1, y1, z2));
	lines.push_back(vec3(x1, y1, z1)), lines.push_back(vec3(x1, y2, z1));
	lines.push_back(vec3(x2, y1, z1)), lines.push_back(vec3(x2, y1, z2));
	lines.push_back(vec3(x2, y1, z1)), lines.push_back(vec3(x2, y2, z1));
	lines.push_back(vec3(x1, y2, z1)), lines.push_back(vec3(x2, y2, z1));
	lines.push_back(vec3(x1, y1, z2)), lines.push_back(vec3(x1, y2, z2));
	lines.push_back(vec3(x1, y2, z1)), lines.push_back(vec3(x1, y2, z2));
	lines.push_back(vec3(x1, y2, z2)), lines.push_back(vec3(x2, y2, z2));
	lines.push_back(vec3(x1, y1, z2)), lines.push_back(vec3(x2, y1, z2));
	lines.push_back(vec3(x2, y2, z1)), lines.push_back(vec3(x2, y2, z2));
	lines.push_back(vec3(x2, y1, z2)), lines.push_back(vec3(x2, y2, z2));
}

void addTriangle(Triangle* tri) {
	if (tri) {
		lines.push_back(tri->p1 - vec3(0.0005, 0.0005, 0.0005));
		lines.push_back(tri->p2 - vec3(0.0005, 0.0005, 0.0005));
		lines.push_back(tri->p2 - vec3(0.0005, 0.0005, 0.0005));
		lines.push_back(tri->p3 - vec3(0.0005, 0.0005, 0.0005));
		lines.push_back(tri->p3 - vec3(0.0005, 0.0005, 0.0005));
		lines.push_back(tri->p1 - vec3(0.0005, 0.0005, 0.0005));
		lines.push_back(tri->p1 + vec3(0.0005, 0.0005, 0.0005));
		lines.push_back(tri->p2 + vec3(0.0005, 0.0005, 0.0005));
		lines.push_back(tri->p2 + vec3(0.0005, 0.0005, 0.0005));
		lines.push_back(tri->p3 + vec3(0.0005, 0.0005, 0.0005));
		lines.push_back(tri->p3 + vec3(0.0005, 0.0005, 0.0005));
		lines.push_back(tri->p1 + vec3(0.0005, 0.0005, 0.0005));
	}
}

// 光线和三角形求交 
float hitTriangle(Triangle* triangle, Ray ray) {

	vec3 p1 = triangle->p1, p2 = triangle->p2, p3 = triangle->p3;
	vec3 S = ray.startPoint;        // 射线起点
	vec3 d = ray.direction;         // 射线方向
	vec3 N = normalize(cross(p2 - p1, p3 - p1));    // 法向量
	if (dot(N, d) > 0.0f) N = -N;   // 获取正确的法向量

									// 如果视线和三角形平行
	if (fabs(dot(N, d)) < 0.00001f) return INF;

	// 距离
	float t = (dot(N, p1) - dot(S, N)) / dot(d, N);
	if (t < 0.0005f) return INF;    // 如果三角形在光线背面

									// 交点计算
	vec3 P = S + d * t;

	// 判断交点是否在三角形中
	vec3 c1 = cross(p2 - p1, P - p1);
	vec3 c2 = cross(p3 - p2, P - p2);
	vec3 c3 = cross(p1 - p3, P - p3);
	if (dot(c1, N) > 0 && dot(c2, N) > 0 && dot(c3, N) > 0) return t;
	if (dot(c1, N) < 0 && dot(c2, N) < 0 && dot(c3, N) < 0) return t;

	光线命中坐标 = P;
	return INF;
}
//float intersect2(Ray ray)
//{
//	光线求交结果 res;
//
//	vec3 S = ray.startPoint;        // 射线起点
//	vec3 d = ray.direction;         // 射线方向
//
//	float OS = length(O - S);
//	float SH = dot(O - S, d);
//	float OH = sqrt(pow(OS, 2) - pow(SH, 2));
//
//	if (OH > R) return res; // OH大于半径则不相交
//
//	float PH = sqrt(pow(R, 2) - pow(OH, 2));
//
//	float t1 = length(SH) - PH;
//	float t2 = length(SH) + PH;
//	float t = (t1 < 0) ? (t2) : (t1);   // 最近距离
//	vec3 P = S + t * d;     // 交点
//
//							// 防止自己交自己
//	if (fabs(t1) < 0.0005f || fabs(t2) < 0.0005f) return res;
//
//	// 装填返回结果
//	res.是否命中 = true;
//	res.与交点的距离 = t;
//	res.光线命中点 = P;
//	//res.material = material;
//	//res.material.normal = normalize(P - O); // 要返回正确的法向
//	return INF;
//}

// 构建 BVH
BVHNode* buildBVH(std::vector<Triangle>& triangles, int l, int r, int n) {
	if (l > r) return 0;

	BVHNode* node = new BVHNode();
	node->AA = vec3(1145141919, 1145141919, 1145141919);
	node->BB = vec3(-1145141919, -1145141919, -1145141919);

	// 计算 AABB
	for (int i = l; i <= r; i++) {
		// 最小点 AA
		float minx = min(triangles[i].p1.x, min(triangles[i].p2.x, triangles[i].p3.x));
		float miny = min(triangles[i].p1.y, min(triangles[i].p2.y, triangles[i].p3.y));
		float minz = min(triangles[i].p1.z, min(triangles[i].p2.z, triangles[i].p3.z));
		node->AA.x = min(node->AA.x, minx);
		node->AA.y = min(node->AA.y, miny);
		node->AA.z = min(node->AA.z, minz);
		// 最大点 BB
		float maxx = max(triangles[i].p1.x, max(triangles[i].p2.x, triangles[i].p3.x));
		float maxy = max(triangles[i].p1.y, max(triangles[i].p2.y, triangles[i].p3.y));
		float maxz = max(triangles[i].p1.z, max(triangles[i].p2.z, triangles[i].p3.z));
		node->BB.x = max(node->BB.x, maxx);
		node->BB.y = max(node->BB.y, maxy);
		node->BB.z = max(node->BB.z, maxz);
	}

	// 不多于 n 个三角形 返回叶子节点
	if ((r - l + 1) <= n) {
		node->n = r - l + 1;
		node->index = l;
		return node;
	}

	// 否则递归建树
	float lenx = node->BB.x - node->AA.x;
	float leny = node->BB.y - node->AA.y;
	float lenz = node->BB.z - node->AA.z;
	// 按 x 划分
	if (lenx >= leny && lenx >= lenz)
		std::sort(triangles.begin() + l, triangles.begin() + r + 1, cmpx);
	// 按 y 划分
	if (leny >= lenx && leny >= lenz)
		std::sort(triangles.begin() + l, triangles.begin() + r + 1, cmpy);
	// 按 z 划分
	if (lenz >= lenx && lenz >= leny)
		std::sort(triangles.begin() + l, triangles.begin() + r + 1, cmpz);

	// 递归
	int mid = (l + r) / 2;
	node->left = buildBVH(triangles, l, mid, n);
	node->right = buildBVH(triangles, mid + 1, r, n);

	return node;
}

// SAH 优化构建 BVH
BVHNode* buildBVHwithSAH(std::vector<Triangle>& triangles, int l, int r, int n) {
	if (l > r) return 0;

	BVHNode* node = new BVHNode();
	node->AA = vec3(1145141919, 1145141919, 1145141919);
	node->BB = vec3(-1145141919, -1145141919, -1145141919);

	// 计算 AABB
	for (int i = l; i <= r; i++) {
		// 最小点 AA
		float minx = min(triangles[i].p1.x, min(triangles[i].p2.x, triangles[i].p3.x));
		float miny = min(triangles[i].p1.y, min(triangles[i].p2.y, triangles[i].p3.y));
		float minz = min(triangles[i].p1.z, min(triangles[i].p2.z, triangles[i].p3.z));
		node->AA.x = min(node->AA.x, minx);
		node->AA.y = min(node->AA.y, miny);
		node->AA.z = min(node->AA.z, minz);
		// 最大点 BB
		float maxx = max(triangles[i].p1.x, max(triangles[i].p2.x, triangles[i].p3.x));
		float maxy = max(triangles[i].p1.y, max(triangles[i].p2.y, triangles[i].p3.y));
		float maxz = max(triangles[i].p1.z, max(triangles[i].p2.z, triangles[i].p3.z));
		node->BB.x = max(node->BB.x, maxx);
		node->BB.y = max(node->BB.y, maxy);
		node->BB.z = max(node->BB.z, maxz);
	}

	// 不多于 n 个三角形 返回叶子节点
	if ((r - l + 1) <= n) {
		node->n = r - l + 1;
		node->index = l;
		return node;
	}

	// 否则递归建树
	float Cost = INF;
	int Axis = 0;
	int Split = (l + r) / 2;
	for (int axis = 0; axis < 3; axis++) {
		// 分别按 x，y，z 轴排序
		if (axis == 0) std::sort(&triangles[0] + l, &triangles[0] + r + 1, cmpx);
		if (axis == 1) std::sort(&triangles[0] + l, &triangles[0] + r + 1, cmpy);
		if (axis == 2) std::sort(&triangles[0] + l, &triangles[0] + r + 1, cmpz);

		// leftMax[i]: [l, i] 中最大的 xyz 值
		// leftMin[i]: [l, i] 中最小的 xyz 值
		std::vector<vec3> leftMax(r - l + 1, vec3(-INF, -INF, -INF));
		std::vector<vec3> leftMin(r - l + 1, vec3(INF, INF, INF));
		// 计算前缀 注意 i-l 以对齐到下标 0
		for (int i = l; i <= r; i++) {
			Triangle& t = triangles[i];
			int bias = (i == l) ? 0 : 1;  // 第一个元素特殊处理

			leftMax[i - l].x = max(leftMax[i - l - bias].x, max(t.p1.x, max(t.p2.x, t.p3.x)));
			leftMax[i - l].y = max(leftMax[i - l - bias].y, max(t.p1.y, max(t.p2.y, t.p3.y)));
			leftMax[i - l].z = max(leftMax[i - l - bias].z, max(t.p1.z, max(t.p2.z, t.p3.z)));

			leftMin[i - l].x = min(leftMin[i - l - bias].x, min(t.p1.x, min(t.p2.x, t.p3.x)));
			leftMin[i - l].y = min(leftMin[i - l - bias].y, min(t.p1.y, min(t.p2.y, t.p3.y)));
			leftMin[i - l].z = min(leftMin[i - l - bias].z, min(t.p1.z, min(t.p2.z, t.p3.z)));
		}

		// rightMax[i]: [i, r] 中最大的 xyz 值
		// rightMin[i]: [i, r] 中最小的 xyz 值
		std::vector<vec3> rightMax(r - l + 1, vec3(-INF, -INF, -INF));
		std::vector<vec3> rightMin(r - l + 1, vec3(INF, INF, INF));
		// 计算后缀 注意 i-l 以对齐到下标 0
		for (int i = r; i >= l; i--) {
			Triangle& t = triangles[i];
			int bias = (i == r) ? 0 : 1;  // 第一个元素特殊处理

			rightMax[i - l].x = max(rightMax[i - l + bias].x, max(t.p1.x, max(t.p2.x, t.p3.x)));
			rightMax[i - l].y = max(rightMax[i - l + bias].y, max(t.p1.y, max(t.p2.y, t.p3.y)));
			rightMax[i - l].z = max(rightMax[i - l + bias].z, max(t.p1.z, max(t.p2.z, t.p3.z)));

			rightMin[i - l].x = min(rightMin[i - l + bias].x, min(t.p1.x, min(t.p2.x, t.p3.x)));
			rightMin[i - l].y = min(rightMin[i - l + bias].y, min(t.p1.y, min(t.p2.y, t.p3.y)));
			rightMin[i - l].z = min(rightMin[i - l + bias].z, min(t.p1.z, min(t.p2.z, t.p3.z)));
		}

		// 遍历寻找分割
		float cost = INF;
		int split = l;
		for (int i = l; i <= r - 1; i++) {
			float lenx, leny, lenz;
			// 左侧 [l, i]
			vec3 leftAA = leftMin[i - l];
			vec3 leftBB = leftMax[i - l];
			lenx = leftBB.x - leftAA.x;
			leny = leftBB.y - leftAA.y;
			lenz = leftBB.z - leftAA.z;
			float leftS = 2.0 * ((lenx * leny) + (lenx * lenz) + (leny * lenz));
			float leftCost = leftS * (i - l + 1);

			// 右侧 [i+1, r]
			vec3 rightAA = rightMin[i + 1 - l];
			vec3 rightBB = rightMax[i + 1 - l];
			lenx = rightBB.x - rightAA.x;
			leny = rightBB.y - rightAA.y;
			lenz = rightBB.z - rightAA.z;
			float rightS = 2.0 * ((lenx * leny) + (lenx * lenz) + (leny * lenz));
			float rightCost = rightS * (r - i);

			// 记录每个分割的最小答案
			float totalCost = leftCost + rightCost;
			if (totalCost < cost) {
				cost = totalCost;
				split = i;
			}
		}
		// 记录每个轴的最佳答案
		if (cost < Cost) {
			Cost = cost;
			Axis = axis;
			Split = split;
		}
	}

	// 按最佳轴分割
	if (Axis == 0) std::sort(&triangles[0] + l, &triangles[0] + r + 1, cmpx);
	if (Axis == 1) std::sort(&triangles[0] + l, &triangles[0] + r + 1, cmpy);
	if (Axis == 2) std::sort(&triangles[0] + l, &triangles[0] + r + 1, cmpz);

	// 递归
	node->left = buildBVHwithSAH(triangles, l, Split, n);
	node->right = buildBVHwithSAH(triangles, Split + 1, r, n);

	return node;
}

void dfsNlevel(BVHNode* root, int depth, int targetDepth) {
	if (root == NULL) return;
	if (targetDepth == depth) {
		addBox(root);
		return;
	}
	dfsNlevel(root->left, depth + 1, targetDepth);
	dfsNlevel(root->right, depth + 1, targetDepth);
}

// 暴力查数组
HitResult hitTriangleArray(Ray ray, std::vector<Triangle>& triangles, int l, int r) {
	HitResult res;
	for (int i = l; i <= r; i++) {
		float d = hitTriangle(&triangles[i], ray);
		if (d < INF && d < res.distance) {
			res.distance = d;
			res.triangle = &triangles[i];
		}
	}
	return res;
}

// 和 aabb 盒子求交，没有交点则返回 -1
float hitAABB(Ray r, vec3 AA, vec3 BB) {
	// 1.0 / direction
	vec3 invdir = vec3(1.0 / r.direction.x, 1.0 / r.direction.y, 1.0 / r.direction.z);

	vec3 in = (BB - r.startPoint) * invdir;
	vec3 out = (AA - r.startPoint) * invdir;

	vec3 tmax = max(in, out);
	vec3 tmin = min(in, out);

	float t1 = min(tmax.x, min(tmax.y, tmax.z));
	float t0 = max(tmin.x, max(tmin.y, tmin.z));



	return (t1 >= t0) ? ((t0 > 0.0) ? (t0) : (t1)) : (-1);
}

// 在 BVH 上遍历求交
HitResult hitBVH(Ray ray, std::vector<Triangle>& triangles, BVHNode* root) {
	if (root == NULL) return HitResult();

	// 是叶子 暴力查
	if (root->n > 0) {
		return hitTriangleArray(ray, triangles, root->n, root->n + root->index - 1);
	}

	// 和左右子树 AABB 求交
	float d1 = INF, d2 = INF;
	if (root->left) d1 = hitAABB(ray, root->left->AA, root->left->BB);
	if (root->right) d2 = hitAABB(ray, root->right->AA, root->right->BB);

	// 递归结果
	HitResult r1, r2, r3;
	if (d1>0) r1 = hitBVH(ray, triangles, root->left);
	if (d2>0) r2 = hitBVH(ray, triangles, root->right);



	r3= r1.distance < r2.distance ? r1 : r2;
	r3.光线命中点 = 光线命中坐标;
	r3.是否命中 = 1;
	return  r3;
}

// ----------------------------------------------------------------------------- //

// 显示回调函数
void display() {

	// 构造模型变换矩阵
	mat4 unit(    // 单位矩阵
		vec4(1, 0, 0, 0),
		vec4(0, 1, 0, 0),
		vec4(0, 0, 1, 0),
		vec4(0, 0, 0, 1)
	);
	mat4 scaleMat = scale(unit, scaleControl);   // xyz缩放0.6倍
	mat4 rotateMat = unit;    // 旋转
	rotateMat = rotate(rotateMat, radians(rotateControl.x), vec3(1, 0, 0)); // 绕x轴转
	rotateMat = rotate(rotateMat, radians(rotateControl.y), vec3(0, 1, 0)); // 绕y轴转
	rotateMat = rotate(rotateMat, radians(rotateControl.z), vec3(0, 0, 1)); // 绕z轴转
	mat4 modelMat = rotateMat * scaleMat;   // 变换级联 -- 生成模型变换矩阵

	GLuint mlocation = glGetUniformLocation(program, "model");  // 名为model的uniform变量的位置索引
	glUniformMatrix4fv(mlocation, 1, GL_FALSE, value_ptr(modelMat));

	GLuint clocation = glGetUniformLocation(program, "color");

	// 绘制
	glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);       // 清空窗口颜色缓存
	glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
	glUniform3fv(clocation, 1, value_ptr(vec3(1, 0, 0)));
	glDrawElements(GL_TRIANGLES, indices.size(), GL_UNSIGNED_INT, 0);

	// 绘制 AABB 盒子  
	glUniform3fv(clocation, 1, value_ptr(vec3(1, 1, 1)));
	glDrawArrays(GL_LINES, vertices.size(), lines.size());
	glutSwapBuffers();  // 交换缓冲区
}

// 鼠标运动函数
double lastX = 0.0, lastY = 0.0;
void mouse(int x, int y)
{
	// 调整旋转
	rotateControl.y += -200 * (x - lastX) / 512;
	rotateControl.x += -200 * (y - lastY) / 512;
	lastX = x, lastY = y;
	glutPostRedisplay();    // 重绘
}

// 鼠标按下
void mouseDown(int button, int state, int x, int y) {
	if (button == GLUT_LEFT_BUTTON && state == GLUT_DOWN) {
		lastX = x, lastY = y;
	}
}

// 鼠标滚轮函数
void mouseWheel(int wheel, int direction, int x, int y) {
	scaleControl.x += 1 * direction * 0.1;
	scaleControl.y += 1 * direction * 0.1;
	scaleControl.z += 1 * direction * 0.1;
	glutPostRedisplay();    // 重绘
}

#include <random>
// 0-1 随机数生成
std::uniform_real_distribution<> dis(0.0, 1.0);
std::random_device rd;
std::mt19937 gen(rd());
double randf()
{
	return dis(gen);
}


// 相机参数
const double SCREEN_Z = 1.1;        // 视平面 z 坐标
const vec3 EYE = vec3(0, 0, 4.0);   // 相机位置
BVHNode* 	root;
//vec3 小图采样2[200 * 200]; 

void 渲染(){
#include<mmintrin.h>


	for (int i = 0; i < WIDTH; i +=2)
	{
		for (int j = 0; j < HEIGHT; j +=2)
		{

			// 像素坐标转投影平面坐标
			double x = 2.0 * double(j) / double(WIDTH) - 1.0;
			double y = 2.0 * double(HEIGHT - i) / double(HEIGHT) - 1.0;
			// MSAA
			x += (randf() - 0.5f) / double(WIDTH);
			y += (randf() - 0.5f) / double(HEIGHT);

			vec3 coord = vec3(x, y, SCREEN_Z);          // 计算投影平面坐标
			vec3 direction = normalize(coord - EYE);    // 计算光线投射方向


														// 生成光线
			Ray ray;
			ray.startPoint = coord;
			ray.direction = direction;

			vec3 color = vec3(0, 0, 0);
			/*	Ray ray;
			ray.startPoint = vec3(0, 0, 1);
			ray.direction = normalize(vec3(0.1, -0.1, -0.7));*/

			// HitResult res = hitTriangleArray(ray, triangles, 0, triangles.size()-1); // 暴力验证
			HitResult res = hitBVH(ray, triangles, root);
			//addTriangle(res.triangle);
			//addLine(ray.startPoint, ray.startPoint + ray.direction * vec3(5, 5, 5));

			if (res.triangle != NULL) { //判断是否命中  得到三角形既命中模型返回颜色
				color = vec3(0, 0.5, 0);

				//小图采样2[i + j] = color;
			}



			buffer[i][j] = RGB(color.x * 255, color.y * 255, color.z * 255);
			//buffer[i][j] = RGB(小图采样2[i + j].x * 255, 小图采样2[i + j].y * 255, 小图采样2[i + j].z * 255);

		}
	}

	glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, WIDTH, HEIGHT, GL_RGBA, GL_UNSIGNED_BYTE, buffer);
	glLoadIdentity();
	glBegin(GL_QUADS);
	glTexCoord2f(0, 0);
	glVertex2f(-1, 1);
	glTexCoord2f(0, 1);
	glVertex2f(-1, -1);
	glTexCoord2f(1, 1);
	glVertex2f(1, -1);
	glTexCoord2f(1, 0);
	glVertex2f(1, 1);
	glEnd();
	glutSwapBuffers();
	++frames;
	if (clock() - clocks>CLOCKS_PER_SEC)
	{
		char title[64];
		sprintf(title, "光线追踪路径追踪混合  FPS:%d", frames);
		glutSetWindowTitle(title);
		clocks = clock();
		frames = 0;
	}
}


int main() {

	// ------------------------------------------------------------------------------------------- //

	// 读 obj
	readObj("2.obj", vertices, indices);
	for (auto& v : vertices) {
		v.x *= 5.0, v.y *= 5.0, v.z *= 5.0;
		v.y -= 0.5;
	}
	//readObj("./models/quad.obj", vertices, indices);
	// 构建 Triangle 数组
	for (int i = 0; i < indices.size(); i += 3) {
		triangles.push_back(Triangle(vertices[indices[i]], vertices[indices[i + 1]], vertices[indices[i + 2]]));
	}

	// 建立 BVH 树
 //root = buildBVH(triangles, 0, triangles.size() - 1, 8);
 
		root = buildBVHwithSAH(triangles, 0, triangles.size() - 1, 80);

	//addBox(root->left); 
	//addBox(root->right);

	dfsNlevel(root, 0, 1);   // 可视化第 n 层 bvh
							 /**/
	// ------------------------------------------------------------------------------------------- //

	int argc = 1;
	char* argv[] = { "MFC_GLUT" };
	clocks = clock();
	frames = 0;
	glutInitWindowSize(WIDTH, HEIGHT);
	glutInit(&argc, argv);
	glutInitDisplayMode(GLUT_RGBA | GLUT_DOUBLE);
	glutCreateWindow("RayTracing");
	glutDisplayFunc(渲染);
	glutIdleFunc(渲染);
	glEnable(GL_TEXTURE_2D);
	glGenTextures(1, &texture);
	glBindTexture(GL_TEXTURE_2D, texture);
	glTexImage2D(GL_TEXTURE_2D, 0, 4, WIDTH, HEIGHT, 0, GL_RGBA, GL_UNSIGNED_BYTE, buffer);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);	// 线形滤波
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);	// 线形滤波

	glutMainLoop();
	return 0;
}
小雨丶
关注
专栏目录
光线追踪渲染实战（二）：BVH 加速遍历结构
AKGWSB 's blog
07-12 1万+
BVH 全称 Bounding Volume Hierarchy，即层次包围盒，是一种场景管理的数据结构。BVH 用 AABB 的盒子（碰撞箱）包围一组三角面片。 光线要击中盒子中的三角形的必要条件，是光线击中盒子。如果光线没有击中盒子，那么必定不会击中盒子里面的所有三角形。 基于这个规律剔除三角形，从而达到减少求交次数的目的，这就是 BVH 这种数据结构的优势
three-mesh-bvh:BVH实现可加快针对Three.js网格的光线投射
05-02
三目BVH 一个BVH实现，可以加快光线投射的速度，并启用three.js网格的相交测试。 以60帧/秒的速度向80,000个多边形模型投射500条光线！ 用 使用预制函数 // Import via ES6 modules import * as THREE from 'three' ; import { computeBoundsTree , disposeBoundsTree , acceleratedRaycast } from 'three-mesh-bvh' ; // Or UMD const { computeBoundsTree , disposeBoundsTree , acceleratedRaycast } = window . MeshBVHLib ; // Add the extension functions THREE . BufferGeometry .
BVH with SAH (Bounding Volume Hierarchy with Surface Area Heuristic)
weixin_30902675的博客
02-12 334
BVH with SAH (Bounding Volume Hierarchy with Surface Area Heuristic) -BVH with SAH (Bounding Volume Hierarchy with Surface Area Heuristic) - 0. Overview 包围层次盒(...
BVH 层次包围结构
最新发布
weixin_47588164的博客
08-28 794
这一篇我们说了BVH的原理和代码实现，它适合在元素较多的场景里做选择。原文链接：https://juejin.cn/post/7407621980574875711。
基于SAH的BVH
qq_43749617的博客
04-25 936
const int nBuckets=12; std::vector<Bounds3> buckets(nBuckets); std::vector<int> numbuckets(nBuckets); BVHBuildNode* BVHAccel::recursiveSAHBuild(std::vector<Object*> objects) { B...
BVH with SAH (Bounding Volume Hierarchy with Surface Area Heuristic)
PBA_WORLD
05-02 1678
BVH with SAH   see Physically Based Rendering (2nd edition) CHAPTER 04. PRIMITIVES AND INTERSECTION ACCELERATION - Bounding Volume Hierarchies
【GAMES101】作业6（提高）含BVH与SAH加速查找算法（SVH）和快速排序算法
ycrsw的博客
04-24 3505
作业描述 在之前的编程练习中，我们实现了基础的光线追踪算法，具体而言是光线传输、光线与三角形求交。我们采用了这样的方法寻找光线与场景的交点：遍历场景中的所有物体，判断光线是否与它相交。在场景中的物体数量不大时，该做法可以取得良好的结果，但当物体数量增多、模型变得更加复杂，该做法将会变得非常低效。因此，我们需要加速结构来加速求交过程。在本次练习中，我们重点关注物体划分算法 Bounding Volume Hierarchy (BVH)。本练习要求你实现 Ray-Bounding Volume 求交与 BVH
Atrc:我的路径追踪器
05-03
两级加速结构（基于SAH的BVH） 重要的采样环境光 G缓冲区输出（反照率，正常，...） 景深 ACES色调映射 图像样本空间低通滤波器 （可选）集成的OIDN库 （可选）集成的Embree库 互动场景编辑器 已知的问题 ...
【GAMES101】作业6（提高）含BVH与SAH加速查找算法和快速排序算法
04-24
SAH（Surface Area Heuristic）是构建BVH时的一种优化策略。SAH的目标是在构建树的过程中最小化遍历成本，即尽可能地均衡划分物体，使得每一层的表面面积比例最小。这样可以减少在查找过程中跨越过多分支的几率。在...
fastbuild bvh
04-19
SAH（表面面积启发式）是一种用于构建BVH的启发式算法，通过最小化遍历过程中可能的节点交叉概率，来优化整个层级结构。 本文讨论了一种快速构建基于SAH的BVH的技术，这项技术能够实现在每一帧中，从零开始重新构建...
RayTracedShadows:该演示实现了BVH构造和GPU遍历以渲染硬阴影
05-30
光线追踪阴影 该演示实现了用于渲染硬阴影的 BVH 构造和 GPU 遍历。 BVH 建设和布局 BVH 是在 CPU 上构建的。 构建过程相当简单，但会生成快速遍历的高质量层次结构。 该树使用自上而下的策略构建，使用表面积启发式...
PBRT笔记(2)——BVH
weixin_33918114的博客
10-31 825
BVH 构建BVH树分三步： 计算每个图元的边界信息并且存储在数组中 使用指定的方法构建树 优化树，使得树更加紧凑 //BVH边界信息，存储了图元号，包围盒以及中心点 struct BVHPrimitiveInfo { BVHPrimitiveInfo() {} BVHPrimitiveInfo(size_t primitiveNumber, const Bounds3f &a...
games101：七，加速光线追踪（AABB、BVH、SAH）+ 作业6
噗噗噗的博客
12-31 1638
game101：七，加速光线追踪（AABB、BVH、SAH）+ 作业6一，轴对齐包围盒(Axis-Aligned Bounding Box)-AABB二，Bounding Volume Hierarchy-BVH三，Surface Area Heuristic-SAH作业6 在光线追踪中，我们不仅要计算多次反射折射，还要计算每个光线的每个接触点与模型的每个三角形是否相交和相交点，计算量巨大，因此学习本节“加速光线追踪”算法来加速这个过程。 一，轴对齐包围盒(Axis-Aligned Bounding Box
Q102：光线追踪场景（2）——PLYs（多种模型汇集）
图形跟班
04-14 1544
0，引入这一章节里，trace的图形包含多种PLY文件表示的图形。 比如：bunny、dragon、hand skeleton、horse等。 主要涉及两件事情： 1，将这些模型添加到场景中； 2，给场景中的图形设置各自的材质和纹理。直接看图啦~~~该场景中包含如下几个部分： 1，后方平面（Phong材质，平面的2D方格纹理）； 2，下方平面（Reflective材质，平面的2D方格纹理
光线求交加速算法：边界体积层次结构(Bounding Volume Hierarchies)1-BVH引入
小龙虾的博客
06-28 2615
光线求交加速算法：边界体积层次结构(Bounding Volume Hierarchies) 光线和物体求交的加速算法中，最常见的是物体(图元)细分和空间细分。边界体积层次结构（BVH）是一种基于图元(primitives)细分的光线相交加速方法，其中，图元被划分为不相交集的层次结构。 （相反，空间细分通常将空间划分为不相交集的层次结构。）下图显示了一个简单场景的边界框层次结构： 其中，图元存储在叶中，每个节点存储其所有子节点图元的边界框。 因此，当光线穿过树时，只要它不与节点的边界相交，就可.
光线追踪—层次包围盒（ Bounding Volume Hierarchies ）
sunshine543123的博客
06-30 3802
原理： 通过一个简单的包围盒把物体包围起来，射线和场景中的物体求交之前，会先和这个包围盒进行求交，如果该射线没有碰到该包围盒，表明该直线一定不会和包围盒里的物体相交；如果该射线碰到该包围盒，那么再来计算射线是否和包围盒中的物体相交。 作用： BVH可以使渲染器更加高效，值得注意的是盒子是可以重叠的。当然，盒子内也可以放其他的盒子，这样我们会得到一个树形结构。 怎样判断和盒子是否相交？ 2D包围盒的边界是一条线，而3D包围盒的边界是一个面 射线可以看为是一个方程：P（t）=A+B*t 将这个公式实际应用 实
光追渲染器开发记录：BVH加速结构构建与射线求交
m0_56399931的博客
04-13 1627
目录 为什么需要加速： BVH概念： BVH的一个节点： 轴对称包围盒AABB： BVH的构建： 核心思想： 求取最大的包围盒： BVH求交： 包围盒求交： 基本思想： 平面求交： 具体做法： 具体的物体求交： 三角面求交： 基本思想： 球体求交： 方法一： 方法二： 学习资料： 上一篇：光追渲染器开发记录：基础渲染架构/线程池/泛型单例_This is MX的博客-CSDN博客https://blog.csdn.net/m0_56399931/article/det
光线求交加速算法：kd-树
小龙虾的博客
07-03 1303
光线求交加速算法：kd-树 空间二分树,即Binary space partitioning(BSP)树利用分割平面自适应地细分空间。 BSP树以包围整个场景的边界框开始。如果框中的图元数量大于某个阈值，则该框将被平面分成两个区域。然后，将图元与它们重叠的区域相关联。如果图元同时位于两个区域，则图元将与两个区域都关联(这与BVH不同，在BVH中，每个图元在拆分后仅分配给两个子组之一)。 拆分过程将递归地继续进行，直到树中的每个叶区域包含足够少的图元，或者直到达到最大深度为止。因为可以将拆分平面放..
KD-Tree
papalqi
02-17 456
Bentley 于 1975 年在 中提出一种多维二叉查找树，即 k d-tree，其中k代表查找空间的维度。k d-tree 可将一个给定的空间根据其存储的记录进行多级分割，每一级轮换使用各个维度并抽取一个记录在该维度上的值将空间或子空间一分为二。 比如 2d-tree，第一级抽取一个记录的 x 值按 x 维度分割，得到两个子空间，接着对两个子空间分别抽取其它记录的 y 值按 y 维度分割，再...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值