557 lines
21 KiB
C++
557 lines
21 KiB
C++
// main.cpp
|
||
// 一个“面片 + 纹理变换 + 递归反射贴图”的简易 Cornell Box 渲染器（PPM 输出）
|
||
// 关键点：
|
||
// - 不从 Camera 对每个像素发射 Ray 求交取色（避免传统 Ray Tracing 思路）
|
||
// - 以“Viewport(屏幕/面片) = 场景中的三角形面片集合”的方式做投影与贴图（类似光栅化/投影贴图）
|
||
// - 对镜面材质：把该三角形当作 current viewport，构造“反射后的虚拟观察点”，递归渲染并把结果作为该三角形的 current 纹理
|
||
//
|
||
// 编译运行：
|
||
// g++ -std=c++17 -O2 -o render main.cpp
|
||
// ./render
|
||
// 输出：output.ppm (P6)
|
||
//
|
||
// 说明：
|
||
// - 这里先忽略 AO、采样漫反射等；漫反射仅用固有颜色/棋盘纹理。
|
||
// - 覆盖关系：用“远到近”排序 + painter 覆盖（O(n log n)），符合你描述的临时方案。
|
||
// - 反射：对每个镜面三角形，递归渲染“该三角形所在平面作为 viewport”的纹理图，再贴回上一级 viewport。
|
||
|
||
#include <algorithm>
|
||
#include <array>
|
||
#include <cassert>
|
||
#include <cmath>
|
||
#include <cstdint>
|
||
#include <fstream>
|
||
#include <iostream>
|
||
#include <limits>
|
||
#include <string>
|
||
#include <utility>
|
||
#include <vector>
|
||
|
||
static constexpr double kEps = 1e-9;
|
||
|
||
struct Vec2 {
|
||
double x = 0, y = 0;
|
||
Vec2() = default;
|
||
Vec2(double _x, double _y) : x(_x), y(_y) {}
|
||
Vec2 operator+(const Vec2& r) const { return {x + r.x, y + r.y}; }
|
||
Vec2 operator-(const Vec2& r) const { return {x - r.x, y - r.y}; }
|
||
Vec2 operator*(double s) const { return {x * s, y * s}; }
|
||
};
|
||
|
||
struct Vec3 {
|
||
double x = 0, y = 0, z = 0;
|
||
Vec3() = default;
|
||
Vec3(double _x, double _y, double _z) : x(_x), y(_y), z(_z) {}
|
||
Vec3 operator+(const Vec3& r) const { return {x + r.x, y + r.y, z + r.z}; }
|
||
Vec3 operator-(const Vec3& r) const { return {x - r.x, y - r.y, z - r.z}; }
|
||
Vec3 operator*(double s) const { return {x * s, y * s, z * s}; }
|
||
Vec3 operator/(double s) const { return {x / s, y / s, z / s}; }
|
||
};
|
||
|
||
static inline double dot(const Vec3& a, const Vec3& b) { return a.x * b.x + a.y * b.y + a.z * b.z; }
|
||
static inline Vec3 cross(const Vec3& a, const Vec3& b) {
|
||
return {a.y * b.z - a.z * b.y, a.z * b.x - a.x * b.z, a.x * b.y - a.y * b.x};
|
||
}
|
||
static inline double length(const Vec3& v) { return std::sqrt(dot(v, v)); }
|
||
static inline Vec3 normalize(const Vec3& v) {
|
||
double len = length(v);
|
||
if (len < kEps) return {0, 0, 0};
|
||
return v / len;
|
||
}
|
||
static inline Vec3 clamp01(const Vec3& c) {
|
||
auto cl = [](double v) { return std::max(0.0, std::min(1.0, v)); };
|
||
return {cl(c.x), cl(c.y), cl(c.z)};
|
||
}
|
||
static inline Vec3 hadamard(const Vec3& a, const Vec3& b) { return {a.x * b.x, a.y * b.y, a.z * b.z}; }
|
||
|
||
struct Plane {
|
||
Vec3 n; // normalized
|
||
double d; // plane eq: dot(n, p) + d = 0
|
||
};
|
||
|
||
static inline Plane makePlaneFromTriangle(const Vec3& a, const Vec3& b, const Vec3& c) {
|
||
Vec3 n = normalize(cross(b - a, c - a));
|
||
double d = -dot(n, a);
|
||
return {n, d};
|
||
}
|
||
|
||
static inline double signedDistance(const Plane& pl, const Vec3& p) { return dot(pl.n, p) + pl.d; }
|
||
|
||
static inline Vec3 reflectPointAcrossPlane(const Vec3& p, const Plane& pl) {
|
||
// p' = p - 2 * dist * n
|
||
double dist = signedDistance(pl, p);
|
||
return p - pl.n * (2.0 * dist);
|
||
}
|
||
|
||
static inline Vec3 reflectVectorAcrossPlane(const Vec3& v, const Plane& pl) {
|
||
// reflect direction v about plane normal: v' = v - 2*dot(v,n)*n
|
||
return v - pl.n * (2.0 * dot(v, pl.n));
|
||
}
|
||
|
||
struct Image {
|
||
int w = 0, h = 0;
|
||
std::vector<Vec3> pix; // linear RGB [0..1]
|
||
Image() = default;
|
||
Image(int _w, int _h, Vec3 clear = {0, 0, 0}) : w(_w), h(_h), pix(size_t(_w) * size_t(_h), clear) {}
|
||
Vec3& at(int x, int y) { return pix[size_t(y) * size_t(w) + size_t(x)]; }
|
||
const Vec3& at(int x, int y) const { return pix[size_t(y) * size_t(w) + size_t(x)]; }
|
||
};
|
||
|
||
static inline uint8_t toSRGB8(double linear) {
|
||
linear = std::max(0.0, std::min(1.0, linear));
|
||
// 简单 gamma 2.2
|
||
double srgb = std::pow(linear, 1.0 / 2.2);
|
||
int v = int(srgb * 255.0 + 0.5);
|
||
v = std::max(0, std::min(255, v));
|
||
return uint8_t(v);
|
||
}
|
||
|
||
static void writePPM_P6(const std::string& path, const Image& img) {
|
||
std::ofstream out(path, std::ios::binary);
|
||
out << "P6\n" << img.w << " " << img.h << "\n255\n";
|
||
for (int y = 0; y < img.h; ++y) {
|
||
for (int x = 0; x < img.w; ++x) {
|
||
Vec3 c = clamp01(img.at(x, y));
|
||
uint8_t r = toSRGB8(c.x);
|
||
uint8_t g = toSRGB8(c.y);
|
||
uint8_t b = toSRGB8(c.z);
|
||
out.write(reinterpret_cast<const char*>(&r), 1);
|
||
out.write(reinterpret_cast<const char*>(&g), 1);
|
||
out.write(reinterpret_cast<const char*>(&b), 1);
|
||
}
|
||
}
|
||
}
|
||
|
||
static inline Vec3 lerp(const Vec3& a, const Vec3& b, double t) { return a * (1.0 - t) + b * t; }
|
||
|
||
struct Material {
|
||
enum class Type { Diffuse, Mirror } type = Type::Diffuse;
|
||
Vec3 baseColor = {1, 1, 1}; // 对 Diffuse：固有色；对 Mirror：金属 tint
|
||
double mirrorStrength = 0.95; // Mirror 时反射占比
|
||
bool checker = false;
|
||
};
|
||
|
||
struct Triangle {
|
||
int id = -1;
|
||
Vec3 p0, p1, p2; // world
|
||
Vec2 uv0, uv1, uv2; // local texture coords
|
||
Material mat;
|
||
};
|
||
|
||
static inline Vec3 triangleNormal(const Triangle& t) {
|
||
return normalize(cross(t.p1 - t.p0, t.p2 - t.p0));
|
||
}
|
||
|
||
static inline Vec3 triangleCentroid(const Triangle& t) {
|
||
return (t.p0 + t.p1 + t.p2) / 3.0;
|
||
}
|
||
|
||
// 2D barycentric in screen space
|
||
static inline bool barycentric2D(const Vec2& a, const Vec2& b, const Vec2& c, const Vec2& p,
|
||
double& w0, double& w1, double& w2) {
|
||
Vec2 v0 = b - a;
|
||
Vec2 v1 = c - a;
|
||
Vec2 v2 = p - a;
|
||
double den = v0.x * v1.y - v0.y * v1.x;
|
||
if (std::abs(den) < kEps) return false;
|
||
double inv = 1.0 / den;
|
||
w1 = (v2.x * v1.y - v2.y * v1.x) * inv;
|
||
w2 = (v0.x * v2.y - v0.y * v2.x) * inv;
|
||
w0 = 1.0 - w1 - w2;
|
||
return true;
|
||
}
|
||
|
||
// 3D barycentric on triangle plane (using areas / cross with normal)
|
||
static inline bool barycentric3D(const Vec3& a, const Vec3& b, const Vec3& c, const Vec3& p,
|
||
double& w0, double& w1, double& w2) {
|
||
Vec3 n = cross(b - a, c - a);
|
||
double area2 = length(n);
|
||
if (area2 < kEps) return false;
|
||
// use oriented areas along normal
|
||
double areaPBC = dot(cross(b - p, c - p), n);
|
||
double areaPCA = dot(cross(c - p, a - p), n);
|
||
double areaPAB = dot(cross(a - p, b - p), n);
|
||
w0 = areaPBC / dot(n, n);
|
||
w1 = areaPCA / dot(n, n);
|
||
w2 = areaPAB / dot(n, n);
|
||
// 这里 w0,w1,w2 的数值尺度已经合理（因为 dot(n,n)=|n|^2）
|
||
// 但数值误差会略大，后续用范围判断即可。
|
||
return true;
|
||
}
|
||
|
||
struct Viewport {
|
||
enum class Kind { Rect, TriangleUV } kind = Kind::Rect;
|
||
|
||
Vec3 origin; // “第一人称”视点（Camera 或 反射后的虚拟点）
|
||
Plane plane; // viewport 平面
|
||
Vec3 planeCenter; // 用于排序/参考
|
||
Vec3 viewDir; // normalize(planeCenter - origin)
|
||
|
||
// 输出图像大小
|
||
int outW = 0;
|
||
int outH = 0;
|
||
|
||
// Rect: 通过 plane 坐标系映射到像素
|
||
Vec3 right; // in plane
|
||
Vec3 up; // in plane
|
||
double halfW = 1;
|
||
double halfH = 1;
|
||
|
||
// TriangleUV: 通过 world 三角形的 UV 映射到像素
|
||
Vec3 tv0, tv1, tv2; // viewport triangle in world (coplanar with plane)
|
||
Vec2 tuv0, tuv1, tuv2;
|
||
|
||
static Viewport makeCameraRect(const Vec3& origin, const Vec3& center, const Vec3& right, const Vec3& up,
|
||
double halfW, double halfH, int outW, int outH) {
|
||
Viewport vp;
|
||
vp.kind = Kind::Rect;
|
||
vp.origin = origin;
|
||
vp.planeCenter = center;
|
||
vp.right = normalize(right);
|
||
vp.up = normalize(up);
|
||
vp.halfW = halfW;
|
||
vp.halfH = halfH;
|
||
Vec3 n = normalize(cross(vp.right, vp.up)); // right x up = normal
|
||
// 让法线朝向 origin（不强制，但有助于一致性）
|
||
if (dot(n, origin - center) < 0) n = n * -1.0;
|
||
vp.plane = {n, -dot(n, center)};
|
||
vp.viewDir = normalize(center - origin);
|
||
vp.outW = outW;
|
||
vp.outH = outH;
|
||
return vp;
|
||
}
|
||
|
||
static Viewport makeTriangleUV(const Vec3& origin, const Triangle& tri, int outW, int outH) {
|
||
Viewport vp;
|
||
vp.kind = Kind::TriangleUV;
|
||
vp.origin = origin;
|
||
vp.tv0 = tri.p0; vp.tv1 = tri.p1; vp.tv2 = tri.p2;
|
||
vp.tuv0 = tri.uv0; vp.tuv1 = tri.uv1; vp.tuv2 = tri.uv2;
|
||
vp.planeCenter = triangleCentroid(tri);
|
||
vp.plane = makePlaneFromTriangle(tri.p0, tri.p1, tri.p2);
|
||
// 让平面法线尽量朝向 origin，便于稳定
|
||
if (dot(vp.plane.n, origin - vp.planeCenter) < 0) {
|
||
vp.plane.n = vp.plane.n * -1.0;
|
||
vp.plane.d = -vp.plane.d;
|
||
}
|
||
vp.viewDir = normalize(vp.planeCenter - origin);
|
||
vp.outW = outW;
|
||
vp.outH = outH;
|
||
return vp;
|
||
}
|
||
|
||
// 将世界点 x（不一定在 plane 上）沿 origin->x 投影到 viewport 平面，并映射到像素坐标
|
||
// 返回 false 表示无交/在背面/落在 viewport 有效区域外
|
||
bool projectWorldPointToPixel(const Vec3& x, Vec2& outPix, double& outT) const {
|
||
Vec3 dir = x - origin;
|
||
double denom = dot(plane.n, dir);
|
||
if (std::abs(denom) < kEps) return false;
|
||
// intersection t where origin + t*dir hits plane
|
||
double t = -(dot(plane.n, origin) + plane.d) / denom;
|
||
if (t <= kEps) return false; // 只接受向前交
|
||
Vec3 q = origin + dir * t; // on plane
|
||
outT = t;
|
||
|
||
if (kind == Kind::Rect) {
|
||
Vec3 rel = q - planeCenter;
|
||
double u = dot(rel, right) / halfW; // [-1,1] ideally
|
||
double v = dot(rel, up) / halfH;
|
||
double px = (u * 0.5 + 0.5) * double(outW - 1);
|
||
double py = (1.0 - (v * 0.5 + 0.5)) * double(outH - 1);
|
||
if (px < -0.5 || px > outW - 0.5 || py < -0.5 || py > outH - 0.5) return false;
|
||
outPix = {px, py};
|
||
return true;
|
||
}
|
||
|
||
// TriangleUV: 要求 q 落在 viewport 三角形内（用 3D 重心判断）
|
||
double w0, w1, w2;
|
||
if (!barycentric3D(tv0, tv1, tv2, q, w0, w1, w2)) return false;
|
||
if (w0 < -1e-4 || w1 < -1e-4 || w2 < -1e-4) return false;
|
||
|
||
Vec2 uv = tuv0 * w0 + tuv1 * w1 + tuv2 * w2;
|
||
if (uv.x < -1e-4 || uv.x > 1.0 + 1e-4 || uv.y < -1e-4 || uv.y > 1.0 + 1e-4) return false;
|
||
|
||
double px = uv.x * double(outW - 1);
|
||
double py = (1.0 - uv.y) * double(outH - 1);
|
||
outPix = {px, py};
|
||
return true;
|
||
}
|
||
};
|
||
|
||
static Vec3 sampleDiffuseTex(const Material& mat, const Vec2& uv) {
|
||
if (!mat.checker) return mat.baseColor;
|
||
// 纯 UV 棋盘
|
||
int cx = int(std::floor(uv.x * 10.0));
|
||
int cy = int(std::floor(uv.y * 10.0));
|
||
bool odd = ((cx + cy) & 1) != 0;
|
||
Vec3 c0 = mat.baseColor;
|
||
Vec3 c1 = lerp(mat.baseColor, Vec3{1, 1, 1}, 0.35);
|
||
return odd ? c1 : c0;
|
||
}
|
||
|
||
// Forward declaration
|
||
static Image renderViewport(const Viewport& vp, const std::vector<Triangle>& scene, int depth, int maxDepth,
|
||
int excludeTriId);
|
||
|
||
// 为镜面三角形生成“当前纹理”（通过递归把它当 viewport 渲染）
|
||
static Image renderMirrorTextureForTriangle(const Triangle& tri, const Vec3& incidentOrigin,
|
||
const std::vector<Triangle>& scene, int depth, int maxDepth,
|
||
int texW, int texH) {
|
||
Plane pl = makePlaneFromTriangle(tri.p0, tri.p1, tri.p2);
|
||
|
||
// 虚拟观察点：把上一级 origin 关于镜面平面反射
|
||
Vec3 virtualOrigin = reflectPointAcrossPlane(incidentOrigin, pl);
|
||
|
||
// 以该镜面三角形为 viewport，把场景渲染到它的 UV 纹理图里
|
||
Viewport triVP = Viewport::makeTriangleUV(virtualOrigin, tri, texW, texH);
|
||
|
||
// 排除自己，避免最直接的反馈
|
||
Image reflection = renderViewport(triVP, scene, depth + 1, maxDepth, tri.id);
|
||
|
||
return reflection;
|
||
}
|
||
|
||
struct ProjectedTri {
|
||
const Triangle* tri = nullptr;
|
||
Vec2 s0, s1, s2; // projected to output pixels
|
||
double sortKey = 0; // larger=nearer or farther? We will sort far->near
|
||
};
|
||
|
||
// 简易 painter：远->近（sortKey 越大越“近”），所以按 sortKey 升序绘制（远先画）
|
||
static Image renderViewport(const Viewport& vp, const std::vector<Triangle>& scene, int depth, int maxDepth,
|
||
int excludeTriId) {
|
||
Image out(vp.outW, vp.outH, Vec3{0.0, 0.0, 0.0});
|
||
|
||
// 为本次渲染维护一个“镜面三角形 -> 纹理图”的临时缓存（只对当前 viewport 有效）
|
||
struct MirrorCacheItem { int triId; Image tex; };
|
||
std::vector<MirrorCacheItem> mirrorTexCache;
|
||
mirrorTexCache.reserve(64);
|
||
|
||
auto getMirrorTex = [&](const Triangle& t) -> const Image* {
|
||
for (auto& it : mirrorTexCache) {
|
||
if (it.triId == t.id) return &it.tex;
|
||
}
|
||
// 纹理分辨率可根据需要调大/调小
|
||
int texW = 256, texH = 256;
|
||
if (depth >= maxDepth) return nullptr;
|
||
Image tex = renderMirrorTextureForTriangle(t, vp.origin, scene, depth, maxDepth, texW, texH);
|
||
mirrorTexCache.push_back({t.id, std::move(tex)});
|
||
return &mirrorTexCache.back().tex;
|
||
};
|
||
|
||
// 1) 收集可投影到 viewport 的三角形，并计算排序 key
|
||
std::vector<ProjectedTri> list;
|
||
list.reserve(scene.size());
|
||
|
||
for (const auto& t : scene) {
|
||
if (t.id == excludeTriId) continue;
|
||
|
||
Vec2 p0, p1, p2;
|
||
double tt0, tt1, tt2;
|
||
if (!vp.projectWorldPointToPixel(t.p0, p0, tt0)) continue;
|
||
if (!vp.projectWorldPointToPixel(t.p1, p1, tt1)) continue;
|
||
if (!vp.projectWorldPointToPixel(t.p2, p2, tt2)) continue;
|
||
|
||
Vec3 c = triangleCentroid(t);
|
||
double key = dot(vp.viewDir, c - vp.origin); // 视线方向上的“深度”
|
||
list.push_back(ProjectedTri{&t, p0, p1, p2, key});
|
||
}
|
||
|
||
std::sort(list.begin(), list.end(), [](const ProjectedTri& a, const ProjectedTri& b) {
|
||
return a.sortKey < b.sortKey; // far -> near
|
||
});
|
||
|
||
// 2) 按远到近绘制（覆盖关系）
|
||
for (const auto& pt : list) {
|
||
const Triangle& tri = *pt.tri;
|
||
|
||
// 镜面材质：先生成该三角形对当前 origin 的“反射纹理”
|
||
const Image* mirrorTex = nullptr;
|
||
if (tri.mat.type == Material::Type::Mirror && depth < maxDepth) {
|
||
mirrorTex = getMirrorTex(tri);
|
||
}
|
||
|
||
// 三角形光栅化到 out（注意：这里是把 tri 的“纹理”投影变换后贴到 viewport 上）
|
||
double minX = std::floor(std::min({pt.s0.x, pt.s1.x, pt.s2.x}));
|
||
double maxX = std::ceil (std::max({pt.s0.x, pt.s1.x, pt.s2.x}));
|
||
double minY = std::floor(std::min({pt.s0.y, pt.s1.y, pt.s2.y}));
|
||
double maxY = std::ceil (std::max({pt.s0.y, pt.s1.y, pt.s2.y}));
|
||
|
||
int x0 = std::max(0, int(minX));
|
||
int x1 = std::min(vp.outW - 1, int(maxX));
|
||
int y0 = std::max(0, int(minY));
|
||
int y1 = std::min(vp.outH - 1, int(maxY));
|
||
|
||
for (int y = y0; y <= y1; ++y) {
|
||
for (int x = x0; x <= x1; ++x) {
|
||
Vec2 p{double(x) + 0.5, double(y) + 0.5};
|
||
double w0, w1, w2;
|
||
if (!barycentric2D(pt.s0, pt.s1, pt.s2, p, w0, w1, w2)) continue;
|
||
if (w0 < -1e-6 || w1 < -1e-6 || w2 < -1e-6) continue;
|
||
|
||
// screen-space 仿射插值 tri 的 UV（这里不做 perspective-correct，符合“变换粘贴”的感觉）
|
||
Vec2 uv = tri.uv0 * w0 + tri.uv1 * w1 + tri.uv2 * w2;
|
||
|
||
Vec3 base = sampleDiffuseTex(tri.mat, uv);
|
||
|
||
if (tri.mat.type == Material::Type::Mirror && mirrorTex) {
|
||
// 镜面：把递归得到的 reflectionTex 作为 tri 的 current 纹理，再叠加 tint
|
||
// mirrorTex 的坐标域就是 tri 的 UV（由 Viewport::TriangleUV 保证）
|
||
int sx = std::max(0, std::min(mirrorTex->w - 1, int(uv.x * (mirrorTex->w - 1) + 0.5)));
|
||
int sy = std::max(0, std::min(mirrorTex->h - 1, int((1.0 - uv.y) * (mirrorTex->h - 1) + 0.5)));
|
||
Vec3 refl = mirrorTex->at(sx, sy);
|
||
|
||
// 简单金属混合：反射为主，baseColor 做 tint
|
||
Vec3 tintedRefl = hadamard(refl, tri.mat.baseColor);
|
||
Vec3 outC = lerp(base, tintedRefl, tri.mat.mirrorStrength);
|
||
|
||
out.at(x, y) = outC;
|
||
} else {
|
||
// 漫反射（当前回合忽略采样/光照，仅贴固有纹理）
|
||
out.at(x, y) = base;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return out;
|
||
}
|
||
|
||
static int gNextTriId = 1;
|
||
|
||
static Triangle makeTri(const Vec3& a, const Vec3& b, const Vec3& c, const Vec2& uva, const Vec2& uvb, const Vec2& uvc,
|
||
const Material& m) {
|
||
Triangle t;
|
||
t.id = gNextTriId++;
|
||
t.p0 = a; t.p1 = b; t.p2 = c;
|
||
t.uv0 = uva; t.uv1 = uvb; t.uv2 = uvc;
|
||
t.mat = m;
|
||
return t;
|
||
}
|
||
|
||
static void addQuadAsTwoTris(std::vector<Triangle>& out,
|
||
const Vec3& a, const Vec3& b, const Vec3& c, const Vec3& d,
|
||
const Material& m,
|
||
const Vec2& uva = {0,0}, const Vec2& uvb = {1,0}, const Vec2& uvc = {1,1}, const Vec2& uvd = {0,1}) {
|
||
// quad (a,b,c,d) in CCW; split to (a,b,c) and (a,c,d)
|
||
out.push_back(makeTri(a, b, c, uva, uvb, uvc, m));
|
||
out.push_back(makeTri(a, c, d, uva, uvc, uvd, m));
|
||
}
|
||
|
||
static void addBox(std::vector<Triangle>& out, const Vec3& center, const Vec3& halfSize, const Material& m) {
|
||
// axis-aligned box, 6 faces, each 2 tris
|
||
Vec3 minP = center - halfSize;
|
||
Vec3 maxP = center + halfSize;
|
||
|
||
Vec3 p000{minP.x, minP.y, minP.z};
|
||
Vec3 p001{minP.x, minP.y, maxP.z};
|
||
Vec3 p010{minP.x, maxP.y, minP.z};
|
||
Vec3 p011{minP.x, maxP.y, maxP.z};
|
||
Vec3 p100{maxP.x, minP.y, minP.z};
|
||
Vec3 p101{maxP.x, minP.y, maxP.z};
|
||
Vec3 p110{maxP.x, maxP.y, minP.z};
|
||
Vec3 p111{maxP.x, maxP.y, maxP.z};
|
||
|
||
// +X (right): p100 p101 p111 p110
|
||
addQuadAsTwoTris(out, p100, p101, p111, p110, m);
|
||
// -X (left): p000 p010 p011 p001
|
||
addQuadAsTwoTris(out, p000, p010, p011, p001, m);
|
||
// +Y (top): p010 p110 p111 p011
|
||
addQuadAsTwoTris(out, p010, p110, p111, p011, m);
|
||
// -Y (bottom): p000 p001 p101 p100
|
||
addQuadAsTwoTris(out, p000, p001, p101, p100, m);
|
||
// +Z (front): p001 p011 p111 p101
|
||
addQuadAsTwoTris(out, p001, p011, p111, p101, m);
|
||
// -Z (back): p000 p100 p110 p010
|
||
addQuadAsTwoTris(out, p000, p100, p110, p010, m);
|
||
}
|
||
|
||
int main() {
|
||
// 输出分辨率
|
||
const int W = 800;
|
||
const int H = 600;
|
||
|
||
// 构造 Cornell Box 场景（用三角形面片）
|
||
std::vector<Triangle> scene;
|
||
scene.reserve(1024);
|
||
|
||
// Cornell box bounds
|
||
// x: [-1,1], y: [-1,1], z: [-2,-6]
|
||
const double x0 = -1.0, x1 = 1.0;
|
||
const double y0 = -1.0, y1 = 1.0;
|
||
const double zNear = -2.0, zBack = -6.0;
|
||
|
||
Material leftWall; leftWall.type = Material::Type::Diffuse; leftWall.baseColor = {0.95, 0.20, 0.20}; leftWall.checker = false;
|
||
Material rightWall; rightWall.type = Material::Type::Diffuse; rightWall.baseColor = {0.20, 0.95, 0.20}; rightWall.checker = false;
|
||
Material backWall; backWall.type = Material::Type::Diffuse; backWall.baseColor = {0.90, 0.90, 0.90}; backWall.checker = false;
|
||
Material floorWall; floorWall.type = Material::Type::Diffuse; floorWall.baseColor = {0.90, 0.90, 0.90}; floorWall.checker = true;
|
||
Material ceilWall; ceilWall.type = Material::Type::Diffuse; ceilWall.baseColor = {0.85, 0.85, 0.85}; ceilWall.checker = false;
|
||
|
||
// 四壁（这里额外加了天花板，便于反射更丰富；如需严格“四壁”，可注释 ceiling）
|
||
// Left wall (x=x0), CCW from inside
|
||
addQuadAsTwoTris(scene,
|
||
Vec3{x0, y0, zNear}, Vec3{x0, y0, zBack}, Vec3{x0, y1, zBack}, Vec3{x0, y1, zNear},
|
||
leftWall);
|
||
|
||
// Right wall (x=x1)
|
||
addQuadAsTwoTris(scene,
|
||
Vec3{x1, y0, zBack}, Vec3{x1, y0, zNear}, Vec3{x1, y1, zNear}, Vec3{x1, y1, zBack},
|
||
rightWall);
|
||
|
||
// Back wall (z=zBack)
|
||
addQuadAsTwoTris(scene,
|
||
Vec3{x0, y0, zBack}, Vec3{x1, y0, zBack}, Vec3{x1, y1, zBack}, Vec3{x0, y1, zBack},
|
||
backWall);
|
||
|
||
// Floor (y=y0)
|
||
addQuadAsTwoTris(scene,
|
||
Vec3{x0, y0, zBack}, Vec3{x1, y0, zBack}, Vec3{x1, y0, zNear}, Vec3{x0, y0, zNear},
|
||
floorWall);
|
||
|
||
// Ceiling (y=y1)
|
||
addQuadAsTwoTris(scene,
|
||
Vec3{x0, y1, zNear}, Vec3{x1, y1, zNear}, Vec3{x1, y1, zBack}, Vec3{x0, y1, zBack},
|
||
ceilWall);
|
||
|
||
// 两个金属盒子（镜面反射）
|
||
Material blueMetal;
|
||
blueMetal.type = Material::Type::Mirror;
|
||
blueMetal.baseColor = {0.35, 0.55, 1.00}; // 蓝色金属 tint
|
||
blueMetal.mirrorStrength = 0.95;
|
||
|
||
Material yellowMetal;
|
||
yellowMetal.type = Material::Type::Mirror;
|
||
yellowMetal.baseColor = {1.00, 0.90, 0.25}; // 黄色金属 tint
|
||
yellowMetal.mirrorStrength = 0.95;
|
||
|
||
// 放在地面上（y0=-1），盒子底面稍微抬一点避免穿插
|
||
addBox(scene, Vec3{-0.45, -0.55, -4.7}, Vec3{0.25, 0.45, 0.25}, blueMetal);
|
||
addBox(scene, Vec3{ 0.45, -0.65, -3.8}, Vec3{0.30, 0.35, 0.30}, yellowMetal);
|
||
|
||
// Camera viewport 抽象为场景中的一个矩形平面（内部用两个三角形覆盖，这里用 Rect viewport 简化映射）
|
||
Vec3 camOrigin{0.0, 0.0, 0.0};
|
||
Vec3 vpCenter{0.0, 0.0, -1.0};
|
||
|
||
// 视场决定 viewport 大小：halfW/halfH
|
||
// 设定垂直 FOV ~ 55°
|
||
double fovY = 55.0 * M_PI / 180.0;
|
||
double halfH = std::tan(fovY * 0.5) * 1.0; // plane 距离为 1
|
||
double halfW = halfH * (double(W) / double(H));
|
||
|
||
Vec3 vpRight{1, 0, 0};
|
||
Vec3 vpUp{0, 1, 0};
|
||
|
||
Viewport cameraVP = Viewport::makeCameraRect(camOrigin, vpCenter, vpRight, vpUp, halfW, halfH, W, H);
|
||
|
||
// 递归深度（镜面反射级数）
|
||
const int maxDepth = 2;
|
||
|
||
std::cerr << "Rendering...\n";
|
||
Image img = renderViewport(cameraVP, scene, /*depth=*/0, maxDepth, /*excludeTriId=*/-1);
|
||
|
||
// 输出
|
||
writePPM_P6("output.ppm", img);
|
||
std::cerr << "Done. Wrote output.ppm\n";
|
||
return 0;
|
||
}
|