1552 lines
46 KiB
C++
1552 lines
46 KiB
C++
#include <algorithm>
|
||
#include <cmath>
|
||
#include <fstream>
|
||
#include <iostream>
|
||
#include <limits>
|
||
#include <memory>
|
||
#include <queue>
|
||
#include <vector>
|
||
|
||
// ============================================================================
|
||
// 基础数学结构
|
||
// ============================================================================
|
||
|
||
struct Vec3 {
|
||
double x, y, z;
|
||
|
||
Vec3(double x = 0, double y = 0, double z = 0) : x(x), y(y), z(z) {
|
||
}
|
||
|
||
Vec3 operator+(const Vec3 &v) const {
|
||
return Vec3(x + v.x, y + v.y, z + v.z);
|
||
}
|
||
Vec3 operator-(const Vec3 &v) const {
|
||
return Vec3(x - v.x, y - v.y, z - v.z);
|
||
}
|
||
Vec3 operator*(double t) const {
|
||
return Vec3(x * t, y * t, z * t);
|
||
}
|
||
Vec3 operator/(double t) const {
|
||
return Vec3(x / t, y / t, z / t);
|
||
}
|
||
Vec3 operator-() const {
|
||
return Vec3(-x, -y, -z);
|
||
}
|
||
|
||
Vec3 &operator+=(const Vec3 &v) {
|
||
x += v.x;
|
||
y += v.y;
|
||
z += v.z;
|
||
return *this;
|
||
}
|
||
Vec3 &operator*=(double t) {
|
||
x *= t;
|
||
y *= t;
|
||
z *= t;
|
||
return *this;
|
||
}
|
||
|
||
double dot(const Vec3 &v) const {
|
||
return x * v.x + y * v.y + z * v.z;
|
||
}
|
||
Vec3 cross(const Vec3 &v) const {
|
||
return Vec3(y * v.z - z * v.y, z * v.x - x * v.z, x * v.y - y * v.x);
|
||
}
|
||
|
||
double length() const {
|
||
return std::sqrt(x * x + y * y + z * z);
|
||
}
|
||
double lengthSquared() const {
|
||
return x * x + y * y + z * z;
|
||
}
|
||
Vec3 normalize() const {
|
||
double l = length();
|
||
return l > 1e-10 ? *this / l : Vec3(0, 0, 0);
|
||
}
|
||
// 关于平面反射点（平面由点planePoint和法向量planeNormal定义）
|
||
// 在 Vec3 类中，确保 reflect 函数正确
|
||
Vec3 reflect(const Vec3 &planePoint, const Vec3 &planeNormal) const {
|
||
Vec3 n = planeNormal.normalize();
|
||
double d = (*this - planePoint).dot(n);
|
||
return *this - n * (2.0 * d);
|
||
}
|
||
};
|
||
|
||
inline Vec3 operator*(double t, const Vec3 &v) {
|
||
return v * t;
|
||
}
|
||
|
||
// ============================================================================
|
||
// 颜色类
|
||
// ============================================================================
|
||
|
||
struct Color {
|
||
double r, g, b;
|
||
|
||
Color(double r = 0, double g = 0, double b = 0) : r(r), g(g), b(b) {
|
||
}
|
||
|
||
Color operator+(const Color &c) const {
|
||
return Color(r + c.r, g + c.g, b + c.b);
|
||
}
|
||
Color operator-(const Color &c) const {
|
||
return Color(r - c.r, g - c.g, b - c.b);
|
||
}
|
||
Color operator*(double t) const {
|
||
return Color(r * t, g * t, b * t);
|
||
}
|
||
Color operator*(const Color &c) const {
|
||
return Color(r * c.r, g * c.g, b * c.b);
|
||
}
|
||
Color operator/(double t) const {
|
||
return Color(r / t, g / t, b / t);
|
||
}
|
||
|
||
Color &operator+=(const Color &c) {
|
||
r += c.r;
|
||
g += c.g;
|
||
b += c.b;
|
||
return *this;
|
||
}
|
||
|
||
Color clamp() const {
|
||
return Color(
|
||
std::max(0.0, std::min(1.0, r)),
|
||
std::max(0.0, std::min(1.0, g)),
|
||
std::max(0.0, std::min(1.0, b)));
|
||
}
|
||
// Gamma校正
|
||
Color gammaCorrect(double gamma = 2.2) const {
|
||
double invGamma = 1.0 / gamma;
|
||
return Color(std::pow(r, invGamma), std::pow(g, invGamma), std::pow(b, invGamma));
|
||
}
|
||
};
|
||
|
||
// ============================================================================
|
||
// 纹理类
|
||
// ============================================================================
|
||
|
||
// ============================================================================
|
||
// 三角形光栅化辅助函数
|
||
// ============================================================================
|
||
|
||
// 2D点结构
|
||
struct Point2D {
|
||
double x, y;
|
||
Point2D(double x = 0, double y = 0) : x(x), y(y) {
|
||
}
|
||
};
|
||
|
||
// 计算2D三角形的有符号面积的两倍
|
||
double signedArea2D(const Point2D &a, const Point2D &b, const Point2D &c) {
|
||
return (b.x - a.x) * (c.y - a.y) - (c.x - a.x) * (b.y - a.y);
|
||
}
|
||
|
||
// 计算2D重心坐标
|
||
bool barycentric2D(const Point2D &p, const Point2D &a, const Point2D &b, const Point2D &c, double &u, double &v, double &w) {
|
||
double area = signedArea2D(a, b, c);
|
||
if (std::abs(area) < 1e-10)
|
||
return false;
|
||
|
||
u = signedArea2D(p, b, c) / area;
|
||
v = signedArea2D(a, p, c) / area;
|
||
w = signedArea2D(a, b, p) / area;
|
||
|
||
return true;
|
||
}
|
||
|
||
class Texture {
|
||
public:
|
||
int width, height;
|
||
std::vector<Color> pixels;
|
||
std::vector<double> depths; // 深度缓冲
|
||
|
||
Texture(int w = 1, int h = 1, const Color &c = Color(0, 0, 0))
|
||
: width(w), height(h), pixels(w * h, c), depths(w * h, 1e30) {
|
||
}
|
||
|
||
Color getPixel(int x, int y) const {
|
||
if (x < 0 || x >= width || y < 0 || y >= height)
|
||
return Color(0, 0, 0);
|
||
return pixels[y * width + x];
|
||
}
|
||
|
||
void setPixel(int x, int y, const Color &c) {
|
||
if (x >= 0 && x < width && y >= 0 && y < height)
|
||
pixels[y * width + x] = c;
|
||
}
|
||
|
||
double getDepth(int x, int y) const {
|
||
if (x < 0 || x >= width || y < 0 || y >= height)
|
||
return 1e30;
|
||
return depths[y * width + x];
|
||
}
|
||
|
||
void setDepth(int x, int y, double d) {
|
||
if (x >= 0 && x < width && y >= 0 && y < height)
|
||
depths[y * width + x] = d;
|
||
}
|
||
|
||
void setPixelWithDepth(int x, int y, const Color &c, double depth) {
|
||
if (x >= 0 && x < width && y >= 0 && y < height) {
|
||
int idx = y * width + x;
|
||
if (depth < depths[idx]) {
|
||
depths[idx] = depth;
|
||
pixels[idx] = c;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 双线性插值采样 (u, v 在 [0, 1] 范围内)
|
||
Color sample(double u, double v) const {
|
||
u = std::max(0.0, std::min(1.0, u));
|
||
v = std::max(0.0, std::min(1.0, v));
|
||
double fx = u * (width - 1);
|
||
double fy = v * (height - 1);
|
||
int x0 = (int)fx, y0 = (int)fy;
|
||
int x1 = std::min(x0 + 1, width - 1);
|
||
int y1 = std::min(y0 + 1, height - 1);
|
||
double tx = fx - x0, ty = fy - y0;
|
||
|
||
Color c00 = getPixel(x0, y0);
|
||
Color c10 = getPixel(x1, y0);
|
||
Color c01 = getPixel(x0, y1);
|
||
Color c11 = getPixel(x1, y1);
|
||
|
||
Color c0 = c00 * (1 - tx) + c10 * tx;
|
||
Color c1 = c01 * (1 - tx) + c11 * tx;
|
||
return c0 * (1 - ty) + c1 * ty;
|
||
}
|
||
|
||
void clear(const Color &c = Color(0, 0, 0)) {
|
||
std::fill(pixels.begin(), pixels.end(), c);
|
||
std::fill(depths.begin(), depths.end(), 1e30);
|
||
}
|
||
// 写入PPM文件
|
||
void writePPM(const std::string &filename) const {
|
||
std::ofstream ofs(filename);
|
||
ofs << "P3\n"
|
||
<< width << " " << height << "\n255\n";
|
||
for (int y = 0; y < height; y++) {
|
||
for (int x = 0; x < width; x++) {
|
||
Color c = getPixel(x, y).clamp().gammaCorrect();
|
||
int ir = static_cast<int>(255.99 * c.r);
|
||
int ig = static_cast<int>(255.99 * c.g);
|
||
int ib = static_cast<int>(255.99 * c.b);
|
||
ofs << ir << " " << ig << " " << ib << "\n";
|
||
}
|
||
}
|
||
ofs.close();
|
||
}
|
||
// 新增：将源纹理拉伸到目标三角形区域并混合粘贴
|
||
// srcTri: 源纹理的三角形UV坐标 (通常是 (0,0), (1,0), (0,1))
|
||
// dstTri: 目标纹理上的三角形像素坐标
|
||
// tint: 颜色染色（用于金属反射）
|
||
// alpha: 混合透明度
|
||
void blendTriangleTexture(
|
||
const Texture &src,
|
||
const Point2D &dst0, const Point2D &dst1, const Point2D &dst2,
|
||
const Color &tint = Color(1, 1, 1),
|
||
double alpha = 1.0) {
|
||
// 计算包围盒
|
||
double minX = std::min({ dst0.x, dst1.x, dst2.x });
|
||
double maxX = std::max({ dst0.x, dst1.x, dst2.x });
|
||
double minY = std::min({ dst0.y, dst1.y, dst2.y });
|
||
double maxY = std::max({ dst0.y, dst1.y, dst2.y });
|
||
|
||
int startX = std::max(0, (int)std::floor(minX));
|
||
int endX = std::min(width - 1, (int)std::ceil(maxX));
|
||
int startY = std::max(0, (int)std::floor(minY));
|
||
int endY = std::min(height - 1, (int)std::ceil(maxY));
|
||
|
||
// 检查三角形面积，避免退化三角形
|
||
double area = signedArea2D(dst0, dst1, dst2);
|
||
if (std::abs(area) < 1e-6)
|
||
return;
|
||
|
||
for (int py = startY; py <= endY; py++) {
|
||
for (int px = startX; px <= endX; px++) {
|
||
Point2D p(px + 0.5, py + 0.5);
|
||
|
||
double u, v, w;
|
||
if (!barycentric2D(p, dst0, dst1, dst2, u, v, w))
|
||
continue;
|
||
|
||
// 放宽边界检查
|
||
const double eps = -0.01;
|
||
if (u < eps || v < eps || w < eps)
|
||
continue;
|
||
if (u > 1.01 || v > 1.01 || w > 1.01)
|
||
continue;
|
||
|
||
// 限制重心坐标到有效范围
|
||
u = std::max(0.0, std::min(1.0, u));
|
||
v = std::max(0.0, std::min(1.0, v));
|
||
w = std::max(0.0, std::min(1.0, w));
|
||
|
||
// 源纹理采样 - 使用整个纹理范围
|
||
// 重心坐标直接映射到纹理UV
|
||
double srcU = v; // 对应dst1方向
|
||
double srcV = w; // 对应dst2方向
|
||
|
||
// 确保在[0,1]范围内
|
||
srcU = std::max(0.0, std::min(1.0, srcU));
|
||
srcV = std::max(0.0, std::min(1.0, srcV));
|
||
|
||
Color srcColor = src.sample(srcU, srcV);
|
||
Color finalColor = srcColor * tint;
|
||
|
||
if (alpha >= 1.0) {
|
||
setPixel(px, py, finalColor);
|
||
} else {
|
||
Color dstColor = getPixel(px, py);
|
||
setPixel(px, py, finalColor * alpha + dstColor * (1.0 - alpha));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 新增：使用UV坐标版本（UV范围0-1）
|
||
void blendTriangleTextureUV(
|
||
const Texture &src,
|
||
const Point2D &uv0, const Point2D &uv1, const Point2D &uv2,
|
||
const Color &tint = Color(1, 1, 1),
|
||
double alpha = 1.0) {
|
||
// 将UV坐标转换为像素坐标（允许负值和超出范围的值）
|
||
Point2D dst0(uv0.x * width, uv0.y * height);
|
||
Point2D dst1(uv1.x * width, uv1.y * height);
|
||
Point2D dst2(uv2.x * width, uv2.y * height);
|
||
|
||
// 计算包围盒并裁剪到纹理范围
|
||
double minX = std::min({ dst0.x, dst1.x, dst2.x });
|
||
double maxX = std::max({ dst0.x, dst1.x, dst2.x });
|
||
double minY = std::min({ dst0.y, dst1.y, dst2.y });
|
||
double maxY = std::max({ dst0.y, dst1.y, dst2.y });
|
||
|
||
// 裁剪到有效范围
|
||
int startX = std::max(0, (int)std::floor(minX));
|
||
int endX = std::min(width - 1, (int)std::ceil(maxX));
|
||
int startY = std::max(0, (int)std::floor(minY));
|
||
int endY = std::min(height - 1, (int)std::ceil(maxY));
|
||
|
||
// 如果完全在范围外，直接返回
|
||
if (startX > endX || startY > endY)
|
||
return;
|
||
|
||
double area = signedArea2D(dst0, dst1, dst2);
|
||
if (std::abs(area) < 0.5)
|
||
return; // 三角形太小
|
||
|
||
for (int py = startY; py <= endY; py++) {
|
||
for (int px = startX; px <= endX; px++) {
|
||
Point2D p(px + 0.5, py + 0.5);
|
||
|
||
double u, v, w;
|
||
if (!barycentric2D(p, dst0, dst1, dst2, u, v, w))
|
||
continue;
|
||
|
||
const double eps = -0.001;
|
||
if (u < eps || v < eps || w < eps)
|
||
continue;
|
||
|
||
double srcU = std::max(0.0, std::min(1.0, v));
|
||
double srcV = std::max(0.0, std::min(1.0, w));
|
||
|
||
Color srcColor = src.sample(srcU, srcV);
|
||
Color finalColor = srcColor * tint;
|
||
|
||
setPixel(px, py, finalColor);
|
||
}
|
||
}
|
||
}
|
||
};
|
||
|
||
// ============================================================================
|
||
// 材质类型枚举
|
||
// ============================================================================
|
||
|
||
enum MaterialType {
|
||
DIFFUSE,
|
||
REFLECTIVE,
|
||
EMISSIVE // 光源
|
||
};
|
||
|
||
// ============================================================================
|
||
// 材质类
|
||
// ============================================================================
|
||
|
||
struct Material {
|
||
MaterialType type;
|
||
Color baseColor;
|
||
Color emissionColor;
|
||
double reflectivity; // 反射率(0-1)
|
||
Material(MaterialType t = DIFFUSE, const Color &color = Color(0.8, 0.8, 0.8))
|
||
: type(t), baseColor(color), emissionColor(0, 0, 0), reflectivity(0.9) {
|
||
}
|
||
|
||
static Material Diffuse(const Color &color) {
|
||
return Material(DIFFUSE, color);
|
||
}
|
||
|
||
static Material Reflective(const Color &color, double refl = 0.95) {
|
||
Material m(REFLECTIVE, color);
|
||
m.reflectivity = refl;
|
||
return m;
|
||
}
|
||
|
||
static Material Emissive(const Color &color, const Color &emission) {
|
||
Material m(EMISSIVE, color);
|
||
m.emissionColor = emission;
|
||
return m;
|
||
}
|
||
};
|
||
|
||
// ============================================================================
|
||
// 三角形类
|
||
// ============================================================================
|
||
|
||
class Triangle {
|
||
public:
|
||
Vec3 v0, v1, v2; // 三个顶点
|
||
Vec3 normal;
|
||
Material material;
|
||
int id; // 唯一标识符，用于避免自相交
|
||
|
||
Triangle() : id(-1) {
|
||
}
|
||
|
||
Triangle(const Vec3 &v0, const Vec3 &v1, const Vec3 &v2,
|
||
const Material &mat = Material(), int id = -1)
|
||
: v0(v0), v1(v1), v2(v2), material(mat), id(id) {
|
||
computeNormal();
|
||
}
|
||
|
||
void computeNormal() {
|
||
normal = (v1 - v0).cross(v2 - v0).normalize();
|
||
}
|
||
|
||
// 获取三角形中心
|
||
Vec3 center() const {
|
||
return (v0 + v1 + v2) / 3.0;
|
||
}
|
||
|
||
// 获取三角形面积
|
||
double area() const {
|
||
return (v1 - v0).cross(v2 - v0).length() / 2.0;
|
||
}
|
||
|
||
// 计算重心坐标
|
||
bool getBarycentricCoords(const Vec3 &p, double &u, double &v, double &w) const {
|
||
Vec3 v0v1 = v1 - v0;
|
||
Vec3 v0v2 = v2 - v0;
|
||
Vec3 v0p = p - v0;
|
||
|
||
double d00 = v0v1.dot(v0v1);
|
||
double d01 = v0v1.dot(v0v2);
|
||
double d11 = v0v2.dot(v0v2);
|
||
double d20 = v0p.dot(v0v1);
|
||
double d21 = v0p.dot(v0v2);
|
||
|
||
double denom = d00 * d11 - d01 * d01;
|
||
if (std::abs(denom) < 1e-10)
|
||
return false;
|
||
|
||
v = (d11 * d20 - d01 * d21) / denom;
|
||
w = (d00 * d21 - d01 * d20) / denom;
|
||
u = 1.0 - v - w;
|
||
|
||
return true;
|
||
}
|
||
|
||
// 检查点是否在三角形内部（使用重心坐标）
|
||
bool containsPoint(const Vec3 &p, double epsilon = 1e-6) const {
|
||
double u, v, w;
|
||
if (!getBarycentricCoords(p, u, v, w))
|
||
return false;
|
||
return u >= -epsilon && v >= -epsilon && w >= -epsilon;
|
||
}
|
||
|
||
// 射线与三角形相交 (Möller–Trumbore算法)
|
||
bool intersectRay(const Vec3 &origin, const Vec3 &dir, double &t, double &u, double &v) const {
|
||
const double EPSILON = 1e-10;
|
||
Vec3 edge1 = v1 - v0;
|
||
Vec3 edge2 = v2 - v0;
|
||
Vec3 h = dir.cross(edge2);
|
||
double a = edge1.dot(h);
|
||
|
||
if (std::abs(a) < EPSILON)
|
||
return false;
|
||
|
||
double f = 1.0 / a;
|
||
Vec3 s = origin - v0;
|
||
u = f * s.dot(h);
|
||
if (u < 0.0 || u > 1.0)
|
||
return false;
|
||
|
||
Vec3 q = s.cross(edge1);
|
||
v = f * dir.dot(q);
|
||
if (v < 0.0 || u + v > 1.0)
|
||
return false;
|
||
|
||
t = f * edge2.dot(q);
|
||
return t > EPSILON;
|
||
}
|
||
|
||
// 获取平面方程 (ax + by + cz + d = 0)
|
||
void getPlaneEquation(double &a, double &b, double &c, double &d) const {
|
||
a = normal.x;
|
||
b = normal.y;
|
||
c = normal.z;
|
||
d = -normal.dot(v0);
|
||
}
|
||
|
||
// 射线与三角形所在平面的交点
|
||
bool intersectPlane(const Vec3 &origin, const Vec3 &dir, Vec3 &intersection) const {
|
||
double denom = normal.dot(dir);
|
||
if (std::abs(denom) < 1e-10)
|
||
return false;
|
||
|
||
double t = normal.dot(v0 - origin) / denom;
|
||
if (t < 0)
|
||
return false;
|
||
|
||
intersection = origin + dir * t;
|
||
return true;
|
||
}
|
||
|
||
// 将世界坐标点转换为三角形的UV坐标
|
||
// 在 Triangle类中，修改 worldToUV 函数
|
||
bool worldToUV(const Vec3 &worldPoint, double &u, double &v) const {
|
||
// 首先将点投影到三角形平面上
|
||
Vec3 pointOnPlane = worldPoint - normal * (worldPoint - v0).dot(normal);
|
||
|
||
// 计算重心坐标
|
||
Vec3 v0v1 = v1 - v0;
|
||
Vec3 v0v2 = v2 - v0;
|
||
Vec3 v0p = pointOnPlane - v0;
|
||
|
||
double d00 = v0v1.dot(v0v1);
|
||
double d01 = v0v1.dot(v0v2);
|
||
double d11 = v0v2.dot(v0v2);
|
||
double d20 = v0p.dot(v0v1);
|
||
double d21 = v0p.dot(v0v2);
|
||
|
||
double denom = d00 * d11 - d01 * d01;
|
||
if (std::abs(denom) < 1e-10)
|
||
return false;
|
||
|
||
double bv = (d11 * d20 - d01 * d21) / denom; // v1的权重
|
||
double bw = (d00 * d21 - d01 * d20) / denom; // v2的权重
|
||
// bu = 1 - bv - bw // v0的权重
|
||
|
||
// UV坐标：v0=(0,0), v1=(1,0), v2=(0,1)
|
||
u = bv;
|
||
v = bw;
|
||
return true;
|
||
}
|
||
|
||
// 将UV坐标转换为世界坐标
|
||
Vec3 uvToWorld(double u, double v) const {
|
||
return v0 * (1.0 - u - v) + v1 * u + v2 * v;
|
||
}
|
||
|
||
// 获取AABB包围盒
|
||
void getAABB(Vec3 &minP, Vec3 &maxP) const {
|
||
minP.x = std::min({ v0.x, v1.x, v2.x });
|
||
minP.y = std::min({ v0.y, v1.y, v2.y });
|
||
minP.z = std::min({ v0.z, v1.z, v2.z });
|
||
maxP.x = std::max({ v0.x, v1.x, v2.x });
|
||
maxP.y = std::max({ v0.y, v1.y, v2.y });
|
||
maxP.z = std::max({ v0.z, v1.z, v2.z });
|
||
}
|
||
};
|
||
|
||
// ============================================================================
|
||
// 视锥体类（由apex和底面三角形定义的四面体）
|
||
// ============================================================================
|
||
|
||
class Frustum {
|
||
public:
|
||
Vec3 apex;
|
||
Triangle base; // 底面三角形
|
||
Vec3 planes[4]; // 4个侧面的法向量（指向内部）
|
||
double planeDs[4]; // 平面方程的d值
|
||
Frustum(const Vec3 &apex, const Triangle &base) : apex(apex), base(base) {
|
||
computePlanes();
|
||
}
|
||
|
||
void computePlanes() {
|
||
// 计算4个平面（3个侧面 + 1个底面）
|
||
// 侧面由apex和底面的边构成
|
||
Vec3 edges[3][2] = {
|
||
{ base.v0, base.v1 },
|
||
{ base.v1, base.v2 },
|
||
{ base.v2, base.v0 }
|
||
};
|
||
|
||
Vec3 baseCenter = base.center();
|
||
|
||
for (int i = 0; i < 3; i++) {
|
||
Vec3 edge = edges[i][1] - edges[i][0];
|
||
Vec3 toApex = apex - edges[i][0];
|
||
planes[i] = edge.cross(toApex).normalize();
|
||
// 确保法向量指向视锥体内部
|
||
Vec3 toCenter = baseCenter - edges[i][0];
|
||
if (planes[i].dot(toCenter) < 0) {
|
||
planes[i] = -planes[i];
|
||
}
|
||
planeDs[i] = -planes[i].dot(edges[i][0]);
|
||
}
|
||
|
||
// 底面（远平面）
|
||
planes[3] = base.normal;
|
||
Vec3 apexToBase = baseCenter - apex;
|
||
if (planes[3].dot(apexToBase) < 0) {
|
||
planes[3] = -planes[3];
|
||
}
|
||
planeDs[3] = -planes[3].dot(base.v0);
|
||
}
|
||
|
||
// 检查点是否在视锥体内
|
||
bool containsPoint(const Vec3 &p) const {
|
||
// 检查点是否在apex的前方（相对于底面）
|
||
Vec3 apexToP = p - apex;
|
||
Vec3 apexToBase = base.center() - apex;
|
||
if (apexToP.dot(apexToBase) < 0)
|
||
return false;
|
||
|
||
// 检查是否在所有平面的正确一侧
|
||
for (int i = 0; i < 4; i++) {
|
||
double dist = planes[i].dot(p) + planeDs[i];
|
||
if (dist < -1e-6)
|
||
return false;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
// 检查三角形是否与视锥体相交或在其内部
|
||
bool intersectsOrContainsTriangle(const Triangle &tri) const {
|
||
// 快速检测：如果三角形的任意顶点在视锥体内
|
||
if (containsPoint(tri.v0) || containsPoint(tri.v1) || containsPoint(tri.v2))
|
||
return true;
|
||
|
||
// 检查视锥体的边是否与三角形相交
|
||
Vec3 frustumVerts[4] = { apex, base.v0, base.v1, base.v2 };
|
||
int edges[6][2] = { { 0, 1 }, { 0, 2 }, { 0, 3 }, { 1, 2 }, { 2, 3 }, { 3, 1 } };
|
||
|
||
for (int i = 0; i < 6; i++) {
|
||
Vec3 p1 = frustumVerts[edges[i][0]];
|
||
Vec3 p2 = frustumVerts[edges[i][1]];
|
||
Vec3 dir = (p2 - p1).normalize();
|
||
double maxT = (p2 - p1).length();
|
||
|
||
double t, u, v;
|
||
if (tri.intersectRay(p1, dir, t, u, v) && t < maxT) {
|
||
return true;
|
||
}
|
||
}
|
||
|
||
// 检查三角形的边是否与视锥体的面相交
|
||
Vec3 triVerts[3] = { tri.v0, tri.v1, tri.v2 };
|
||
Triangle frustumFaces[4] = {
|
||
Triangle(apex, base.v0, base.v1),
|
||
Triangle(apex, base.v1, base.v2),
|
||
Triangle(apex, base.v2, base.v0),
|
||
base
|
||
};
|
||
|
||
for (int i = 0; i < 3; i++) {
|
||
Vec3 p1 = triVerts[i];
|
||
Vec3 p2 = triVerts[(i + 1) % 3];
|
||
Vec3 dir = (p2 - p1).normalize();
|
||
double maxT = (p2 - p1).length();
|
||
|
||
for (int j = 0; j < 4; j++) {
|
||
double t, u, v;
|
||
if (frustumFaces[j].intersectRay(p1, dir, t, u, v) && t < maxT) {
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
};
|
||
|
||
//============================================================================
|
||
// 简化的可见性检测类
|
||
// ============================================================================
|
||
|
||
class VisibilityChecker {
|
||
public:
|
||
Vec3 cameraOrigin;
|
||
Triangle viewport;
|
||
Vec3 viewDir; // 视线方向
|
||
|
||
VisibilityChecker(const Vec3 &origin, const Triangle &vp)
|
||
: cameraOrigin(origin), viewport(vp) {
|
||
viewDir = (viewport.center() - cameraOrigin).normalize();
|
||
}
|
||
|
||
// 检查三角形是否可能在视野内
|
||
// 简化方法：检查三角形是否在相机前方，且投影到viewport平面上有交集
|
||
bool isTriangleVisible(const Triangle &tri) const {
|
||
// 检查三角形中心是否在相机前方
|
||
Vec3 toTri = tri.center() - cameraOrigin;
|
||
if (toTri.dot(viewDir) <= 0.01)
|
||
return false;
|
||
|
||
// 检查三角形的任意顶点投影是否可能落在viewport附近
|
||
Vec3 verts[3] = { tri.v0, tri.v1, tri.v2 };
|
||
int validCount = 0;
|
||
|
||
for (int i = 0; i < 3; i++) {
|
||
Vec3 dir = (verts[i] - cameraOrigin).normalize();
|
||
// 检查方向是否大致朝向viewport
|
||
if (dir.dot(viewDir) > 0.01) {
|
||
validCount++;
|
||
}
|
||
}
|
||
|
||
return validCount > 0;
|
||
}
|
||
|
||
// 计算三角形顶点在viewport平面上的投影
|
||
// 返回是否所有顶点都能成功投影
|
||
bool projectTriangle(const Triangle &tri, Vec3 projected[3]) const {
|
||
Vec3 verts[3] = { tri.v0, tri.v1, tri.v2 };
|
||
|
||
for (int i = 0; i < 3; i++) {
|
||
Vec3 dir = (verts[i] - cameraOrigin);
|
||
double dirLen = dir.length();
|
||
if (dirLen < 1e-10)
|
||
return false;
|
||
dir = dir / dirLen;
|
||
|
||
// 与viewport平面求交
|
||
double denom = viewport.normal.dot(dir);
|
||
if (std::abs(denom) < 1e-10)
|
||
return false;
|
||
|
||
double t = viewport.normal.dot(viewport.v0 - cameraOrigin) / denom;
|
||
if (t <= 0)
|
||
return false; // 在相机后方
|
||
|
||
projected[i] = cameraOrigin + dir * t;
|
||
}
|
||
return true;
|
||
}
|
||
};
|
||
|
||
// ============================================================================
|
||
// 前向声明
|
||
// ============================================================================
|
||
|
||
class Scene;
|
||
|
||
// ============================================================================
|
||
// 渲染函数声明
|
||
// ============================================================================
|
||
|
||
// 新增一个辅助结构来传递viewport信息
|
||
struct ViewportInfo {
|
||
bool isRectViewport; // 是否是矩形viewport（相机viewport）
|
||
Vec3 topLeft;
|
||
Vec3 right, down;
|
||
double width, height;
|
||
|
||
ViewportInfo() : isRectViewport(false) {
|
||
}
|
||
|
||
ViewportInfo(const Vec3 &tl, const Vec3 &r, const Vec3 &d, double w, double h)
|
||
: isRectViewport(true), topLeft(tl), right(r), down(d), width(w), height(h) {
|
||
}
|
||
|
||
// 将世界坐标转换为UV
|
||
bool worldToUV(const Vec3 &worldPoint, double &u, double &v) const {
|
||
Vec3 toPoint = worldPoint - topLeft;
|
||
u = toPoint.dot(right) / width;
|
||
v = toPoint.dot(down) / height;
|
||
return true;
|
||
}
|
||
};
|
||
|
||
Texture renderTriangleWithTriangle(
|
||
const std::vector<Triangle *> &triangles,
|
||
const Vec3 &cameraOrigin,
|
||
const Triangle &viewport,
|
||
int estimatedWidth,
|
||
int estimatedHeight,
|
||
int maxDepth,
|
||
int currentDepth,
|
||
int excludeId,
|
||
const ViewportInfo *vpInfo = nullptr // 新增参数
|
||
);
|
||
|
||
// ============================================================================
|
||
// 场景类
|
||
// ============================================================================
|
||
|
||
class Scene {
|
||
public:
|
||
std::vector<Triangle> triangles;
|
||
int nextId = 0;
|
||
|
||
void addTriangle(const Vec3 &v0, const Vec3 &v1, const Vec3 &v2, const Material &mat) {
|
||
triangles.emplace_back(v0, v1, v2, mat, nextId++);
|
||
}
|
||
|
||
// 添加一个四边形（由两个三角形组成）
|
||
void addQuad(const Vec3 &v0, const Vec3 &v1, const Vec3 &v2, const Vec3 &v3, const Material &mat) {
|
||
addTriangle(v0, v1, v2, mat);
|
||
addTriangle(v0, v2, v3, mat);
|
||
}
|
||
|
||
// 添加一个盒子
|
||
void addBox(const Vec3 &minP, const Vec3 &maxP, const Material &mat) {
|
||
Vec3 v[8] = {
|
||
Vec3(minP.x, minP.y, minP.z),
|
||
Vec3(maxP.x, minP.y, minP.z),
|
||
Vec3(maxP.x, maxP.y, minP.z),
|
||
Vec3(minP.x, maxP.y, minP.z),
|
||
Vec3(minP.x, minP.y, maxP.z),
|
||
Vec3(maxP.x, minP.y, maxP.z),
|
||
Vec3(maxP.x, maxP.y, maxP.z),
|
||
Vec3(minP.x, maxP.y, maxP.z)
|
||
};
|
||
|
||
// 前面 (z = maxP.z)
|
||
addQuad(v[4], v[5], v[6], v[7], mat);
|
||
// 后面 (z = minP.z)
|
||
addQuad(v[1], v[0], v[3], v[2], mat);
|
||
// 左面 (x = minP.x)
|
||
addQuad(v[0], v[4], v[7], v[3], mat);
|
||
// 右面 (x = maxP.x)
|
||
addQuad(v[5], v[1], v[2], v[6], mat);
|
||
// 顶面 (y = maxP.y)
|
||
addQuad(v[7], v[6], v[2], v[3], mat);
|
||
// 底面 (y = minP.y)
|
||
addQuad(v[0], v[1], v[5], v[4], mat);
|
||
}
|
||
|
||
std::vector<Triangle *> getTrianglePtrs() {
|
||
std::vector<Triangle *> ptrs;
|
||
for (auto &tri : triangles) {
|
||
ptrs.push_back(&tri);
|
||
}
|
||
return ptrs;
|
||
}
|
||
};
|
||
Texture renderTriangleWithTriangle(
|
||
const std::vector<Triangle *> &triangles,
|
||
const Vec3 &cameraOrigin,
|
||
const Triangle &viewport,
|
||
int estimatedWidth,
|
||
int estimatedHeight,
|
||
int maxDepth,
|
||
int currentDepth,
|
||
int excludeId,
|
||
const ViewportInfo *vpInfo) {
|
||
Texture result(estimatedWidth, estimatedHeight);
|
||
|
||
// 终止条件
|
||
if (currentDepth >= maxDepth || estimatedWidth < 4 || estimatedHeight < 4) {
|
||
if (viewport.material.type == EMISSIVE) {
|
||
result.clear(viewport.material.emissionColor);
|
||
} else {
|
||
result.clear(viewport.material.baseColor * 0.3);
|
||
}
|
||
return result;
|
||
}
|
||
|
||
// 漫反射材质：直接返回着色后的基础颜色
|
||
if (viewport.material.type == DIFFUSE) {
|
||
Vec3 lightDir = Vec3(0, 1, 0.5).normalize();
|
||
double intensity = std::max(0.3, std::abs(viewport.normal.dot(lightDir)));
|
||
result.clear(viewport.material.baseColor * intensity);
|
||
return result;
|
||
}
|
||
|
||
// 发光材质
|
||
if (viewport.material.type == EMISSIVE) {
|
||
result.clear(viewport.material.emissionColor);
|
||
return result;
|
||
}
|
||
|
||
// ========== 反射材质处理 ==========
|
||
|
||
// 初始化为暗色（无反射时的基础色）
|
||
result.clear(viewport.material.baseColor * 0.1);
|
||
|
||
// 创建可见性检测器
|
||
VisibilityChecker checker(cameraOrigin, viewport);
|
||
|
||
// 收集可见三角形并按距离排序
|
||
struct TriangleDist {
|
||
Triangle *tri;
|
||
double distance;
|
||
};
|
||
std::vector<TriangleDist> visibleTriangles;
|
||
|
||
for (Triangle *tri : triangles) {
|
||
if (tri->id == viewport.id || tri->id == excludeId)
|
||
continue;
|
||
|
||
if (checker.isTriangleVisible(*tri)) {
|
||
double dist = (tri->center() - cameraOrigin).length();
|
||
visibleTriangles.push_back({ tri, dist });
|
||
}
|
||
}
|
||
|
||
// 按距离排序（由远到近）
|
||
std::sort(visibleTriangles.begin(), visibleTriangles.end(), [](const TriangleDist &a, const TriangleDist &b) {
|
||
return a.distance > b.distance;
|
||
});
|
||
|
||
std::cout << "Depth " << currentDepth << ": Found " << visibleTriangles.size()
|
||
<< " visible triangles" << std::endl;
|
||
|
||
for (const auto &td : visibleTriangles) {
|
||
Triangle *tri = td.tri;
|
||
|
||
Vec3 projected[3];
|
||
if (!checker.projectTriangle(*tri, projected))
|
||
continue;
|
||
|
||
// ===== 修改UV计算部分 =====
|
||
Point2D uvCoords[3];
|
||
bool uvValid = true;
|
||
|
||
for (int i = 0; i < 3; i++) {
|
||
double u, v;
|
||
if (vpInfo && vpInfo->isRectViewport) {
|
||
// 使用矩形viewport的UV坐标系
|
||
vpInfo->worldToUV(projected[i], u, v);
|
||
} else {
|
||
// 使用三角形的UV坐标系
|
||
if (!viewport.worldToUV(projected[i], u, v)) {
|
||
uvValid = false;
|
||
break;
|
||
}
|
||
}
|
||
uvCoords[i] = Point2D(u, v);
|
||
}
|
||
if (!uvValid)
|
||
continue;
|
||
|
||
// ===== 添加调试输出 =====
|
||
if (currentDepth == 0 && tri->material.type == REFLECTIVE) {
|
||
std::cout << "Metal tri " << tri->id << " UV: ("
|
||
<< uvCoords[0].x << "," << uvCoords[0].y << ") ("
|
||
<< uvCoords[1].x << "," << uvCoords[1].y << ") ("
|
||
<< uvCoords[2].x << "," << uvCoords[2].y << ")" << std::endl;
|
||
}
|
||
|
||
// 检查投影是否在viewport范围内
|
||
double minU = std::min({ uvCoords[0].x, uvCoords[1].x, uvCoords[2].x });
|
||
double maxU = std::max({ uvCoords[0].x, uvCoords[1].x, uvCoords[2].x });
|
||
double minV = std::min({ uvCoords[0].y, uvCoords[1].y, uvCoords[2].y });
|
||
double maxV = std::max({ uvCoords[0].y, uvCoords[1].y, uvCoords[2].y });
|
||
|
||
// 如果完全在viewport外，跳过
|
||
if (maxU < 0 || minU > 1 || maxV < 0 || minV > 1)
|
||
continue;
|
||
|
||
// 获取目标三角形的纹理
|
||
Texture subTexture;
|
||
if (tri->material.type == REFLECTIVE) {
|
||
// 对于反射材质，递归计算
|
||
// 将相机关于目标三角形对称
|
||
Vec3 newOrigin = cameraOrigin.reflect(tri->center(), tri->normal);
|
||
|
||
double projArea = std::abs(signedArea2D(uvCoords[0], uvCoords[1], uvCoords[2]));
|
||
int subW = std::max(8, (int)(estimatedWidth * std::sqrt(projArea) * 0.8));
|
||
int subH = std::max(8, (int)(estimatedHeight * std::sqrt(projArea) * 0.8));
|
||
subW = std::min(subW, estimatedWidth);
|
||
subH = std::min(subH, estimatedHeight);
|
||
|
||
subTexture = renderTriangleWithTriangle(
|
||
triangles, newOrigin, *tri,
|
||
subW, subH, maxDepth, currentDepth + 1, viewport.id);
|
||
// 在处理反射材质时，添加测试
|
||
// if (viewport.material.type == REFLECTIVE && currentDepth > 0) {
|
||
// // 测试：直接返回一个明显的颜色，验证反射路径是否被执行
|
||
// result.clear(Color(1, 0, 1)); // 洋红色
|
||
// return result;
|
||
// }
|
||
} else if (tri->material.type == EMISSIVE) {
|
||
// 发光材质
|
||
subTexture = Texture(16, 16, tri->material.emissionColor);
|
||
} else {
|
||
// 漫反射材质
|
||
Vec3 lightDir = Vec3(0, 1, 0.5).normalize();
|
||
double intensity = std::max(0.3, std::abs(tri->normal.dot(lightDir)));
|
||
subTexture = Texture(16, 16, tri->material.baseColor * intensity);
|
||
}
|
||
|
||
// 计算染色（金属会给反射染色）
|
||
Color tint = viewport.material.baseColor * viewport.material.reflectivity;
|
||
|
||
// 粘贴纹理
|
||
result.blendTriangleTextureUV(subTexture, uvCoords[0], uvCoords[1], uvCoords[2], tint, 1.0);
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
// // ============================================================================
|
||
// // 核心渲染函数
|
||
// // ============================================================================
|
||
// Texture renderTriangleWithTriangle(
|
||
// const std::vector<Triangle*>& triangles,
|
||
// const Vec3& cameraOrigin,
|
||
// const Triangle& viewport,
|
||
// int estimatedWidth,
|
||
// int estimatedHeight,
|
||
// int maxDepth,
|
||
// int currentDepth,
|
||
// int excludeId)
|
||
// {
|
||
// // 创建当前视口的纹理
|
||
// Texture result(estimatedWidth, estimatedHeight, viewport.material.baseColor);
|
||
//
|
||
// // 终止条件：达到最大深度
|
||
// if (currentDepth >= maxDepth) {
|
||
// if (viewport.material.type == EMISSIVE) {
|
||
// result.clear(viewport.material.emissionColor);
|
||
// }
|
||
// return result;
|
||
// }
|
||
//
|
||
// // 漫反射材质：直接返回基础颜色
|
||
// if (viewport.material.type == DIFFUSE) {
|
||
// Vec3 lightDir = Vec3(0.5, 1, 0.3).normalize();
|
||
// double intensity = std::max(0.2, std::abs(viewport.normal.dot(lightDir)));
|
||
// Color shadedColor = viewport.material.baseColor * intensity;
|
||
// result.clear(shadedColor);
|
||
// return result;
|
||
// }
|
||
//
|
||
// // 发光材质
|
||
// if (viewport.material.type == EMISSIVE) {
|
||
// result.clear(viewport.material.emissionColor);
|
||
// return result;
|
||
// }
|
||
//
|
||
// //========== 反射材质处理 ==========
|
||
//
|
||
// // 用较暗的基础色初始化（环境光贡献）
|
||
// Color ambientColor = viewport.material.baseColor * 0.05;
|
||
// result.clear(ambientColor);
|
||
//
|
||
// // 构建视锥体
|
||
// Frustum frustum(cameraOrigin, viewport);
|
||
//
|
||
// // 收集与视锥体相交的三角形，按距离排序（由远到近）
|
||
// struct TriangleDist {
|
||
// Triangle* tri;
|
||
// double distance;
|
||
// bool operator>(const TriangleDist& other) const {
|
||
// return distance > other.distance;
|
||
// }
|
||
// };
|
||
//
|
||
// std::vector<TriangleDist> visibleTriangles;
|
||
//
|
||
// for (Triangle* tri : triangles) {
|
||
// if (tri->id == viewport.id || tri->id == excludeId) continue;
|
||
//
|
||
// Vec3 triCenter = tri->center();
|
||
// Vec3 toTri = triCenter - cameraOrigin;
|
||
// Vec3 viewDir = viewport.center() - cameraOrigin;
|
||
// if (toTri.dot(viewDir) <= 0) continue;
|
||
//
|
||
// if (frustum.intersectsOrContainsTriangle(*tri)) {
|
||
// double dist = toTri.length();
|
||
// visibleTriangles.push_back({tri, dist});
|
||
// }
|
||
// }
|
||
//
|
||
// // 按距离排序（由远到近）
|
||
// std::sort(visibleTriangles.begin(), visibleTriangles.end(),[](const TriangleDist& a, const TriangleDist& b) {
|
||
// return a.distance > b.distance;
|
||
// });
|
||
//
|
||
// // ========== 遍历并粘贴纹理 ==========
|
||
//
|
||
// for (const auto& td : visibleTriangles) {
|
||
// Triangle* tri = td.tri;
|
||
//
|
||
// // 计算目标三角形三个顶点投影到当前viewport平面上的交点
|
||
// Vec3 triVerts[3] = {tri->v0, tri->v1, tri->v2};
|
||
// Vec3 projectedVerts[3];
|
||
// bool allValid = true;
|
||
//
|
||
// for (int i = 0; i < 3; i++) {
|
||
// Vec3 dir = (triVerts[i] - cameraOrigin).normalize();
|
||
// Vec3 intersection;
|
||
//
|
||
// if (viewport.intersectPlane(cameraOrigin, dir, intersection)) {
|
||
// projectedVerts[i] = intersection;
|
||
// } else {
|
||
// allValid = false;
|
||
// break;
|
||
// }
|
||
// }
|
||
//
|
||
// if (!allValid) continue;
|
||
//
|
||
// // 将投影点转换为viewport的UV坐标
|
||
// Point2D uvCoords[3];
|
||
// bool uvValid = true;
|
||
// for (int i = 0; i < 3; i++) {
|
||
// double u, v;
|
||
// if (viewport.worldToUV(projectedVerts[i], u, v)) {
|
||
// uvCoords[i] = Point2D(u, v);
|
||
// } else {
|
||
// uvValid = false;
|
||
// break;
|
||
// }
|
||
// }
|
||
//
|
||
// if (!uvValid) continue;
|
||
//
|
||
// // 递归获取目标三角形的纹理
|
||
// Vec3 newCameraOrigin = cameraOrigin.reflect(tri->center(), tri->normal);
|
||
// // 估算子纹理大小
|
||
// double projArea = std::abs(signedArea2D(uvCoords[0], uvCoords[1], uvCoords[2]));
|
||
// int subWidth = std::max(8, (int)(estimatedWidth * std::sqrt(projArea)));
|
||
// int subHeight = std::max(8, (int)(estimatedHeight * std::sqrt(projArea)));
|
||
// subWidth = std::min(subWidth, estimatedWidth);
|
||
// subHeight = std::min(subHeight, estimatedHeight);
|
||
// Texture subTexture = renderTriangleWithTriangle(
|
||
// triangles, newCameraOrigin, *tri,
|
||
// subWidth, subHeight,
|
||
// maxDepth, currentDepth + 1, viewport.id
|
||
// );
|
||
//
|
||
// // 计算金属染色和反射率
|
||
// Color metalTint = viewport.material.baseColor * viewport.material.reflectivity;
|
||
// // 直接将子纹理拉伸粘贴到当前纹理
|
||
// result.blendTriangleTextureUV(subTexture, uvCoords[0], uvCoords[1], uvCoords[2], metalTint, 1.0);
|
||
// }
|
||
//
|
||
// return result;
|
||
// }
|
||
//
|
||
// Texture renderTriangleWithTriangle(
|
||
// const std::vector<Triangle *> &triangles,
|
||
// const Vec3 &cameraOrigin,
|
||
// const Triangle &viewport,
|
||
// int estimatedWidth,
|
||
// int estimatedHeight,
|
||
// int maxDepth,
|
||
// int currentDepth,
|
||
// int excludeId) {
|
||
// // 创建当前视口的纹理
|
||
// Texture result(estimatedWidth, estimatedHeight, viewport.material.baseColor);
|
||
//
|
||
// // 终止条件：达到最大深度或面积太小
|
||
// if (currentDepth >= maxDepth) {
|
||
// // 对于发光材质，返回发光颜色
|
||
// if (viewport.material.type == EMISSIVE) {
|
||
// result.clear(viewport.material.emissionColor);
|
||
// }
|
||
// return result;
|
||
// }
|
||
//
|
||
// // 如果是漫反射材质，直接返回基础颜色
|
||
// if (viewport.material.type == DIFFUSE) {
|
||
// // 添加简单的着色（基于法线方向）
|
||
// Vec3 lightDir = Vec3(0.5, 1, 0.3).normalize();
|
||
// double intensity = std::max(0.2, std::abs(viewport.normal.dot(lightDir)));
|
||
// Color shadedColor = viewport.material.baseColor * intensity;
|
||
// result.clear(shadedColor);
|
||
// return result;
|
||
// }
|
||
//
|
||
// // 如果是发光材质
|
||
// if (viewport.material.type == EMISSIVE) {
|
||
// result.clear(viewport.material.emissionColor);
|
||
// return result;
|
||
// }
|
||
//
|
||
// // 对于反射材质，需要递归处理
|
||
// // 首先用基础颜色初始化
|
||
// result.clear(viewport.material.baseColor * 0.05); // 微弱的基础色
|
||
//
|
||
// // 构建视锥体
|
||
// Frustum frustum(cameraOrigin, viewport);
|
||
//
|
||
// // 收集与视锥体相交的三角形，并按距离排序
|
||
// struct TriangleDist {
|
||
// Triangle *tri;
|
||
// double distance;
|
||
// bool operator>(const TriangleDist &other) const {
|
||
// return distance > other.distance; // 远的优先（用于由远到近渲染）
|
||
// }
|
||
// };
|
||
//
|
||
// std::priority_queue<TriangleDist, std::vector<TriangleDist>, std::greater<TriangleDist>> pq;
|
||
//
|
||
// for (Triangle *tri : triangles) {
|
||
// // 跳过自身和被排除的三角形
|
||
// if (tri->id == viewport.id || tri->id == excludeId)
|
||
// continue;
|
||
//
|
||
// // 检查三角形是否在相机前方
|
||
// Vec3 triCenter = tri->center();
|
||
// Vec3 toTri = triCenter - cameraOrigin;
|
||
// Vec3 viewDir = viewport.center() - cameraOrigin;
|
||
// if (toTri.dot(viewDir) <= 0)
|
||
// continue;
|
||
//
|
||
// // 检查三角形是否与视锥体相交
|
||
// if (frustum.intersectsOrContainsTriangle(*tri)) {
|
||
// double dist = (triCenter - cameraOrigin).length();
|
||
// pq.push({ tri, dist });
|
||
// }
|
||
// }
|
||
//
|
||
// // 将优先队列转换为向量（从远到近）
|
||
// std::vector<Triangle *> sortedTriangles;
|
||
// while (!pq.empty()) {
|
||
// sortedTriangles.push_back(pq.top().tri);
|
||
// pq.pop();
|
||
// }
|
||
// std::reverse(sortedTriangles.begin(), sortedTriangles.end()); // 变成由远到近
|
||
//
|
||
// // 遍历每个三角形，将其投影到当前视口上
|
||
// for (Triangle *tri : sortedTriangles) {
|
||
// // 计算目标三角形顶点在当前视口上的投影位置
|
||
// Vec3 projectedVerts[3];
|
||
// bool allValid = true;
|
||
//
|
||
// Vec3 triVerts[3] = { tri->v0, tri->v1, tri->v2 };
|
||
//
|
||
// for (int i = 0; i < 3; i++) {
|
||
// Vec3 dir = (triVerts[i] - cameraOrigin).normalize();
|
||
// Vec3 intersection;
|
||
//
|
||
// if (viewport.intersectPlane(cameraOrigin, dir, intersection)) {
|
||
// // 检查交点是否在视口三角形内（或附近）
|
||
// projectedVerts[i] = intersection;
|
||
// } else {
|
||
// allValid = false;
|
||
// break;
|
||
// }
|
||
// }
|
||
//
|
||
// if (!allValid)
|
||
// continue;
|
||
//
|
||
// // 将投影的3D坐标转换为视口的2D UV坐标
|
||
// Point2D uvCoords[3];
|
||
// for (int i = 0; i < 3; i++) {
|
||
// double u, v;
|
||
// viewport.worldToUV(projectedVerts[i], u, v);
|
||
// uvCoords[i] = Point2D(u, v);
|
||
// }
|
||
//
|
||
// // 递归获取目标三角形应显示的纹理
|
||
// // 对于反射，将相机原点关于目标三角形平面对称
|
||
// Vec3 newCameraOrigin = cameraOrigin.reflect(tri->center(), tri->normal);
|
||
//
|
||
// // 估算子纹理大小（基于投影面积）
|
||
// double projArea = std::abs(signedArea2D(uvCoords[0], uvCoords[1], uvCoords[2]));
|
||
// int subWidth = std::max(4, (int)(estimatedWidth * std::sqrt(projArea) * 0.5));
|
||
// int subHeight = std::max(4, (int)(estimatedHeight * std::sqrt(projArea) * 0.5));
|
||
//
|
||
// // 限制子纹理大小
|
||
// subWidth = std::min(subWidth, estimatedWidth);
|
||
// subHeight = std::min(subHeight, estimatedHeight);
|
||
// Texture subTexture = renderTriangleWithTriangle(
|
||
// triangles, newCameraOrigin, *tri,
|
||
// subWidth, subHeight,
|
||
// maxDepth, currentDepth + 1, viewport.id);
|
||
//
|
||
// // 将子纹理变换并绘制到当前纹理上
|
||
// // 使用扫描线算法进行三角形光栅化
|
||
//
|
||
// // 计算包围盒
|
||
// double minU = std::min({ uvCoords[0].x, uvCoords[1].x, uvCoords[2].x });
|
||
// double maxU = std::max({ uvCoords[0].x, uvCoords[1].x, uvCoords[2].x });
|
||
// double minV = std::min({ uvCoords[0].y, uvCoords[1].y, uvCoords[2].y });
|
||
// double maxV = std::max({ uvCoords[0].y, uvCoords[1].y, uvCoords[2].y });
|
||
//
|
||
// // 转换为像素坐标
|
||
// int startX = std::max(0, (int)(minU * estimatedWidth) - 1);
|
||
// int endX = std::min(estimatedWidth - 1, (int)(maxU * estimatedWidth) + 1);
|
||
// int startY = std::max(0, (int)(minV * estimatedHeight) - 1);
|
||
// int endY = std::min(estimatedHeight - 1, (int)(maxV * estimatedHeight) + 1);
|
||
//
|
||
// // 计算到目标三角形的距离（用于深度测试）
|
||
// double triDist = (tri->center() - cameraOrigin).length();
|
||
//
|
||
// // 光栅化三角形
|
||
// for (int py = startY; py <= endY; py++) {
|
||
// for (int px = startX; px <= endX; px++) {
|
||
// // 当前像素的UV坐标
|
||
// double u = (px + 0.5) / estimatedWidth;
|
||
// double v = (py + 0.5) / estimatedHeight;
|
||
// Point2D p(u, v);
|
||
//
|
||
// // 计算相对于投影三角形的重心坐标
|
||
// double bu, bv, bw;
|
||
// if (!barycentric2D(p, uvCoords[0], uvCoords[1], uvCoords[2], bu, bv, bw))
|
||
// continue;
|
||
//
|
||
// // 检查是否在三角形内
|
||
// const double eps = -0.001; // 稍微放宽以避免间隙
|
||
// if (bu < eps || bv < eps || bw < eps)
|
||
// continue;
|
||
//
|
||
// // 使用重心坐标在子纹理中采样
|
||
// // 子纹理的UV对应于目标三角形的顶点
|
||
// // 在源三角形中，顶点UV为 (0,0), (1,0), (0,1)
|
||
// double srcU = bv; // 对应v1
|
||
// double srcV = bw; // 对应v2
|
||
//
|
||
// Color sampledColor = subTexture.sample(srcU, srcV);
|
||
//
|
||
// // // 应用反射率衰减
|
||
// // sampledColor = sampledColor * viewport.material.reflectivity;
|
||
// //
|
||
// // // 混合到结果纹理（使用深度测试）
|
||
// // result.setPixelWithDepth(px, py, sampledColor, triDist);
|
||
//
|
||
// // 应用反射率衰减，并与金属基础色混合
|
||
// Color metalTint = viewport.material.baseColor; // 金属染色
|
||
// sampledColor = sampledColor * metalTint * viewport.material.reflectivity;
|
||
//
|
||
// // 可选：添加非反射部分的基础色贡献
|
||
// Color finalColor = sampledColor + metalTint * (1.0 - viewport.material.reflectivity) * 0.1;
|
||
//
|
||
// result.setPixelWithDepth(px, py, sampledColor, triDist);
|
||
// }
|
||
// }
|
||
// }
|
||
//
|
||
// return result;
|
||
// }
|
||
|
||
// ============================================================================
|
||
// 相机类
|
||
// ============================================================================
|
||
|
||
class Camera {
|
||
public:
|
||
Vec3 origin;
|
||
Vec3 lookAt;
|
||
Vec3 up;
|
||
double fov; // 垂直视场角（度）
|
||
int width, height;
|
||
|
||
// 两个视口三角形
|
||
Triangle viewportTri1, viewportTri2;
|
||
|
||
// 新增：viewport矩形的四个角和坐标轴
|
||
Vec3 vpTopLeft, vpTopRight, vpBottomLeft, vpBottomRight;
|
||
Vec3 vpRight, vpDown; // viewport的水平和垂直方向
|
||
Vec3 vpNormal;
|
||
double vpWidth, vpHeight;
|
||
|
||
Camera(const Vec3 &origin, const Vec3 &lookAt, const Vec3 &up,
|
||
double fov, int width, int height)
|
||
: origin(origin), lookAt(lookAt), up(up), fov(fov), width(width), height(height) {
|
||
computeViewportTriangles();
|
||
}
|
||
|
||
void computeViewportTriangles() {
|
||
Vec3 forward = (lookAt - origin).normalize();
|
||
Vec3 right = forward.cross(up).normalize();
|
||
Vec3 camUp = right.cross(forward).normalize();
|
||
|
||
double aspectRatio = (double)width / height;
|
||
double fovRad = fov * M_PI / 180.0;
|
||
double viewportDist = 1.0;
|
||
double viewportHeight = 2.0 * viewportDist * std::tan(fovRad / 2.0);
|
||
double viewportWidth = viewportHeight * aspectRatio;
|
||
|
||
Vec3 viewportCenter = origin + forward * viewportDist;
|
||
|
||
Vec3 halfRight = right * (viewportWidth / 2.0);
|
||
Vec3 halfUp = camUp * (viewportHeight / 2.0);
|
||
|
||
// 保存viewport矩形信息
|
||
vpTopLeft = viewportCenter - halfRight + halfUp;
|
||
vpTopRight = viewportCenter + halfRight + halfUp;
|
||
vpBottomLeft = viewportCenter - halfRight - halfUp;
|
||
vpBottomRight = viewportCenter + halfRight - halfUp;
|
||
|
||
vpRight = right;
|
||
vpDown = -camUp; // 向下为正（图像坐标系）
|
||
vpNormal = forward;
|
||
vpWidth = viewportWidth;
|
||
vpHeight = viewportHeight;
|
||
|
||
Material viewportMat = Material::Reflective(Color(1, 1, 1), 1.0);
|
||
viewportTri1 = Triangle(vpBottomLeft, vpBottomRight, vpTopLeft, viewportMat, -100);
|
||
viewportTri2 = Triangle(vpBottomRight, vpTopRight, vpTopLeft, viewportMat, -101);
|
||
}
|
||
// 新增：将世界坐标转换为viewport的UV坐标（相对于整个矩形）
|
||
bool worldToViewportUV(const Vec3 &worldPoint, double &u, double &v) const {
|
||
// 将点投影到viewport平面
|
||
Vec3 toPoint = worldPoint - vpTopLeft;
|
||
|
||
// 计算在viewport坐标系中的位置
|
||
u = toPoint.dot(vpRight) / vpWidth;
|
||
v = toPoint.dot(vpDown) / vpHeight;
|
||
|
||
return true;
|
||
}
|
||
|
||
Texture render(Scene &scene, int maxDepth = 3) {
|
||
Texture finalImage(width, height);
|
||
|
||
auto trianglePtrs = scene.getTrianglePtrs();
|
||
|
||
// 创建viewport信息
|
||
ViewportInfo vpInfo(vpTopLeft, vpRight, vpDown, vpWidth, vpHeight);
|
||
|
||
std::cout << "Rendering viewport..." << std::endl;
|
||
|
||
// 只渲染一次，使用矩形viewport
|
||
// 创建一个虚拟的viewport三角形（实际上覆盖整个矩形）
|
||
Material viewportMat = Material::Reflective(Color(1, 1, 1), 1.0);
|
||
Triangle fullViewport(vpTopLeft, vpBottomRight, vpTopRight, viewportMat, -100);
|
||
fullViewport.normal = vpNormal;
|
||
Texture tex = renderTriangleWithTriangle(
|
||
trianglePtrs, origin, fullViewport,
|
||
width, height, maxDepth, 0, -1, &vpInfo);
|
||
|
||
// 直接复制纹理到最终图像
|
||
for (int y = 0; y < height; y++) {
|
||
for (int x = 0; x < width; x++) {
|
||
double u = (x + 0.5) / width;
|
||
double v = (y + 0.5) / height;
|
||
finalImage.setPixel(x, y, tex.sample(u, v));
|
||
}
|
||
}
|
||
|
||
return finalImage;
|
||
}
|
||
};
|
||
|
||
// ============================================================================
|
||
// 创建康奈尔盒子场景
|
||
// ============================================================================
|
||
|
||
void createCornellBoxScene(Scene &scene) {
|
||
// 康奈尔盒子尺寸
|
||
double size = 5.0;
|
||
double halfSize = size / 2.0;
|
||
|
||
// 材质定义
|
||
Material whiteDiffuse = Material::Diffuse(Color(0.73, 0.73, 0.73));
|
||
Material redDiffuse = Material::Diffuse(Color(0.65, 0.05, 0.05));
|
||
Material greenDiffuse = Material::Diffuse(Color(0.12, 0.45, 0.15));
|
||
Material blueMetal = Material::Reflective(Color(0.1, 0.2, 0.6), 0.85);
|
||
Material yellowMetal = Material::Reflective(Color(0.8, 0.7, 0.1), 0.85);
|
||
Material lightMat = Material::Emissive(Color(1, 1, 1), Color(15, 15, 15));
|
||
|
||
// 地板 (白色)
|
||
scene.addQuad(
|
||
Vec3(-halfSize, -halfSize, -halfSize),
|
||
Vec3(halfSize, -halfSize, -halfSize),
|
||
Vec3(halfSize, -halfSize, halfSize),
|
||
Vec3(-halfSize, -halfSize, halfSize),
|
||
whiteDiffuse);
|
||
|
||
// 天花板 (白色)
|
||
scene.addQuad(
|
||
Vec3(-halfSize, halfSize, halfSize),
|
||
Vec3(halfSize, halfSize, halfSize),
|
||
Vec3(halfSize, halfSize, -halfSize),
|
||
Vec3(-halfSize, halfSize, -halfSize),
|
||
whiteDiffuse);
|
||
|
||
// 后墙 (白色)
|
||
scene.addQuad(
|
||
Vec3(-halfSize, -halfSize, -halfSize),
|
||
Vec3(-halfSize, halfSize, -halfSize),
|
||
Vec3(halfSize, halfSize, -halfSize),
|
||
Vec3(halfSize, -halfSize, -halfSize),
|
||
whiteDiffuse);
|
||
|
||
// 左墙 (红色)
|
||
scene.addQuad(
|
||
Vec3(-halfSize, -halfSize, halfSize),
|
||
Vec3(-halfSize, halfSize, halfSize),
|
||
Vec3(-halfSize, halfSize, -halfSize),
|
||
Vec3(-halfSize, -halfSize, -halfSize),
|
||
redDiffuse);
|
||
|
||
// 右墙 (绿色)
|
||
scene.addQuad(
|
||
Vec3(halfSize, -halfSize, -halfSize),
|
||
Vec3(halfSize, halfSize, -halfSize),
|
||
Vec3(halfSize, halfSize, halfSize),
|
||
Vec3(halfSize, -halfSize, halfSize),
|
||
greenDiffuse);
|
||
|
||
// 光源(天花板中央的小矩形)
|
||
// double lightSize = 1.0;
|
||
// scene.addQuad(
|
||
// Vec3(-lightSize, halfSize - 0.01, -lightSize),
|
||
// Vec3(-lightSize, halfSize - 0.01, lightSize),
|
||
// Vec3(lightSize, halfSize - 0.01, lightSize),
|
||
// Vec3(lightSize, halfSize - 0.01, -lightSize),
|
||
// lightMat);
|
||
|
||
// 蓝色金属盒子 (左侧)
|
||
double box1Size = 1.2;
|
||
Vec3 box1Min(-halfSize + 0.8, -halfSize, -0.5);
|
||
Vec3 box1Max = box1Min + Vec3(box1Size, box1Size * 2, box1Size);
|
||
scene.addBox(box1Min, box1Max, blueMetal);
|
||
|
||
// 黄色金属盒子 (右侧)
|
||
double box2Size = 1.2;
|
||
Vec3 box2Min(halfSize - 0.8 - box2Size, -halfSize, 0.3);
|
||
Vec3 box2Max = box2Min + Vec3(box2Size, box2Size * 1.5, box2Size);
|
||
scene.addBox(box2Min, box2Max, yellowMetal);
|
||
}
|
||
|
||
// ============================================================================
|
||
// 主函数
|
||
// ============================================================================
|
||
|
||
int main() {
|
||
std::cout << "=== 面片变换渲染器 - 康奈尔盒子 ===" << std::endl;
|
||
|
||
// 创建场景
|
||
Scene scene;
|
||
createCornellBoxScene(scene);
|
||
|
||
std::cout << "场景创建完成，共" << scene.triangles.size() << " 个三角形" << std::endl;
|
||
|
||
// 设置相机
|
||
int width = 1024;
|
||
int height = 1024;
|
||
Vec3 cameraPos(0, 0, 12);
|
||
Vec3 lookAt(0, 0, 0);
|
||
Vec3 up(0, 1, 0);
|
||
double fov = 45.0;
|
||
|
||
Camera camera(cameraPos, lookAt, up, fov, width, height);
|
||
|
||
std::cout << "开始渲染..." << std::endl;
|
||
|
||
// 渲染
|
||
int maxReflectionDepth = 3; // 最大反射深度
|
||
Texture image = camera.render(scene, maxReflectionDepth);
|
||
|
||
// 保存图像
|
||
std::string filename = "cornell_box_rt9.ppm";
|
||
image.writePPM(filename);
|
||
|
||
std::cout << "渲染完成！图像已保存到 " << filename << std::endl;
|
||
|
||
return 0;
|
||
}
|