831 lines
25 KiB
C++
831 lines
25 KiB
C++
// cornell_patchstep_fixed.cpp
|
||
// g++ -std=c++17 -O2 cornell_patchstep_fixed.cpp -o render && ./render
|
||
// 输出：out.ppm
|
||
//
|
||
// 修复点（对应你的反馈）：
|
||
// - 之前递归时“下一级 viewport 在最终图片中占哪块区域”的信息虽然隐含在 vm.screenUV/clip 中，
|
||
// 但逻辑上不够显式，容易在扩展/改动时导致下级按“全屏”比例写入。
|
||
// - 现在为 renderTriangleWithTriangle / renderViewport 显式增加参数：
|
||
// `viewportRegion` = 当前 viewport 在最终图片中的屏幕UV三角形(3个二维坐标)。
|
||
// - 所有“投影到屏幕”的计算都通过 viewportRegion 完成；所有写入也强制 clip 在 viewportRegion 内。
|
||
// - 向下递归时，会根据“当前三角形在当前 viewport 上的投影 triScreenUV”计算出下一级 viewportRegion 并传入。
|
||
|
||
#include <algorithm>
|
||
#include <array>
|
||
#include <cassert>
|
||
#include <cmath>
|
||
#include <cstdint>
|
||
#include <fstream>
|
||
#include <iostream>
|
||
#include <limits>
|
||
#include <optional>
|
||
#include <string>
|
||
#include <utility>
|
||
#include <vector>
|
||
|
||
static constexpr double kEps = 1e-9;
|
||
|
||
static inline double clamp01(double x) {
|
||
return x < 0.0 ? 0.0 : (x > 1.0 ? 1.0 : x);
|
||
}
|
||
static inline int clampi(int x, int lo, int hi) {
|
||
return x < lo ? lo : (x > hi ? hi : x);
|
||
}
|
||
|
||
struct Vec2 {
|
||
double x = 0, y = 0;
|
||
Vec2() = default;
|
||
Vec2(double xx, double yy) : x(xx), y(yy) {
|
||
}
|
||
Vec2 operator+(const Vec2 &o) const {
|
||
return Vec2 { x + o.x, y + o.y };
|
||
}
|
||
Vec2 operator-(const Vec2 &o) const {
|
||
return Vec2 { x - o.x, y - o.y };
|
||
}
|
||
Vec2 operator*(double s) const {
|
||
return Vec2 { x * s, y * s };
|
||
}
|
||
};
|
||
|
||
static inline double dot(const Vec2 &a, const Vec2 &b) {
|
||
return a.x * b.x + a.y * b.y;
|
||
}
|
||
static inline double cross2(const Vec2 &a, const Vec2 &b) {
|
||
return a.x * b.y - a.y * b.x;
|
||
}
|
||
|
||
struct Vec3 {
|
||
double x = 0, y = 0, z = 0;
|
||
Vec3() = default;
|
||
Vec3(double xx, double yy, double zz) : x(xx), y(yy), z(zz) {
|
||
}
|
||
Vec3 operator+(const Vec3 &o) const {
|
||
return Vec3 { x + o.x, y + o.y, z + o.z };
|
||
}
|
||
Vec3 operator-(const Vec3 &o) const {
|
||
return Vec3 { x - o.x, y - o.y, z - o.z };
|
||
}
|
||
Vec3 operator*(double s) const {
|
||
return Vec3 { x * s, y * s, z * s };
|
||
}
|
||
Vec3 operator/(double s) const {
|
||
return Vec3 { x / s, y / s, z / s };
|
||
}
|
||
};
|
||
|
||
static inline Vec3 operator*(double s, const Vec3 &v) {
|
||
return v * 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 Vec3 {
|
||
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 Vec3 { 0, 0, 0 };
|
||
return v / len;
|
||
}
|
||
|
||
struct Plane {
|
||
Vec3 n; // unit normal
|
||
double d; // n·x + d = 0
|
||
};
|
||
|
||
static inline Plane planeFromTriangle(const Vec3 &a, const Vec3 &b, const Vec3 &c) {
|
||
Vec3 n = normalize(cross(b - a, c - a));
|
||
double d = -dot(n, a);
|
||
return Plane { n, d };
|
||
}
|
||
|
||
static inline double planeSignedDistance(const Plane &p, const Vec3 &x) {
|
||
return dot(p.n, x) + p.d;
|
||
}
|
||
|
||
static inline Vec3 reflectPointAcrossPlane(const Vec3 &point, const Plane &p) {
|
||
double dist = planeSignedDistance(p, point);
|
||
return point - 2.0 * dist * p.n;
|
||
}
|
||
|
||
struct Basis2DOnPlane {
|
||
Vec3 origin;
|
||
Vec3 ux;
|
||
Vec3 uy;
|
||
Vec3 n;
|
||
};
|
||
|
||
static inline Basis2DOnPlane makePlaneBasis(const Vec3 &a, const Vec3 &b, const Vec3 &c) {
|
||
Vec3 n = normalize(cross(b - a, c - a));
|
||
Vec3 ux = normalize(b - a);
|
||
Vec3 uy = normalize(cross(n, ux));
|
||
return Basis2DOnPlane { a, ux, uy, n };
|
||
}
|
||
|
||
static inline Vec2 to2D(const Basis2DOnPlane &basis, const Vec3 &p) {
|
||
Vec3 v = p - basis.origin;
|
||
return Vec2 { dot(v, basis.ux), dot(v, basis.uy) };
|
||
}
|
||
|
||
static inline Vec3 barycentric2D(const Vec2 &p, const Vec2 &a, const Vec2 &b, const Vec2 &c) {
|
||
Vec2 v0 = b - a;
|
||
Vec2 v1 = c - a;
|
||
Vec2 v2 = p - a;
|
||
double den = cross2(v0, v1);
|
||
if (std::fabs(den) < kEps)
|
||
return Vec3 { -1, -1, -1 };
|
||
double v = cross2(v2, v1) / den;
|
||
double w = cross2(v0, v2) / den;
|
||
double u = 1.0 - v - w;
|
||
return Vec3 { u, v, w };
|
||
}
|
||
|
||
static inline bool pointInTri2D(const Vec2 &p, const Vec2 &a, const Vec2 &b, const Vec2 &c) {
|
||
Vec3 bc = barycentric2D(p, a, b, c);
|
||
return bc.x >= -1e-12 && bc.y >= -1e-12 && bc.z >= -1e-12;
|
||
}
|
||
|
||
static inline bool segIntersect2D(const Vec2 &a, const Vec2 &b, const Vec2 &c, const Vec2 &d) {
|
||
auto orient = [](const Vec2 &p, const Vec2 &q, const Vec2 &r) {
|
||
return cross2(q - p, r - p);
|
||
};
|
||
double o1 = orient(a, b, c);
|
||
double o2 = orient(a, b, d);
|
||
double o3 = orient(c, d, a);
|
||
double o4 = orient(c, d, b);
|
||
|
||
auto onSeg = [](const Vec2 &p, const Vec2 &q, const Vec2 &r) {
|
||
return std::min(p.x, r.x) - 1e-12 <= q.x && q.x <= std::max(p.x, r.x) + 1e-12 && std::min(p.y, r.y) - 1e-12 <= q.y && q.y <= std::max(p.y, r.y) + 1e-12;
|
||
};
|
||
|
||
if ((o1 * o2 < 0) && (o3 * o4 < 0))
|
||
return true;
|
||
if (std::fabs(o1) < 1e-12 && onSeg(a, c, b))
|
||
return true;
|
||
if (std::fabs(o2) < 1e-12 && onSeg(a, d, b))
|
||
return true;
|
||
if (std::fabs(o3) < 1e-12 && onSeg(c, a, d))
|
||
return true;
|
||
if (std::fabs(o4) < 1e-12 && onSeg(c, b, d))
|
||
return true;
|
||
return false;
|
||
}
|
||
|
||
static inline bool triOverlap2D(const std::array<Vec2, 3> &t0, const std::array<Vec2, 3> &t1) {
|
||
for (int i = 0; i < 3; i++) {
|
||
if (pointInTri2D(t0[i], t1[0], t1[1], t1[2]))
|
||
return true;
|
||
if (pointInTri2D(t1[i], t0[0], t0[1], t0[2]))
|
||
return true;
|
||
}
|
||
for (int i = 0; i < 3; i++) {
|
||
Vec2 a0 = t0[i], b0 = t0[(i + 1) % 3];
|
||
for (int j = 0; j < 3; j++) {
|
||
Vec2 a1 = t1[j], b1 = t1[(j + 1) % 3];
|
||
if (segIntersect2D(a0, b0, a1, b1))
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// 3D 三角形相交（满足你“Triangle类及相关运算”的要求；渲染主流程不依赖它）
|
||
static inline void triAABB(const Vec3 &a, const Vec3 &b, const Vec3 &c, Vec3 &mn, Vec3 &mx) {
|
||
mn = Vec3 { std::min({ a.x, b.x, c.x }), std::min({ a.y, b.y, c.y }), std::min({ a.z, b.z, c.z }) };
|
||
mx = Vec3 { std::max({ a.x, b.x, c.x }), std::max({ a.y, b.y, c.y }), std::max({ a.z, b.z, c.z }) };
|
||
}
|
||
|
||
static inline bool aabbOverlap(const Vec3 &mn0, const Vec3 &mx0, const Vec3 &mn1, const Vec3 &mx1) {
|
||
return (mn0.x <= mx1.x + 1e-12 && mx0.x + 1e-12 >= mn1.x) && (mn0.y <= mx1.y + 1e-12 && mx0.y + 1e-12 >= mn1.y) && (mn0.z <= mx1.z + 1e-12 && mx0.z + 1e-12 >= mn1.z);
|
||
}
|
||
|
||
static inline bool segmentTriangleIntersect(const Vec3 &p0, const Vec3 &p1,
|
||
const Vec3 &a, const Vec3 &b, const Vec3 &c,
|
||
double &tOut) {
|
||
Vec3 dir = p1 - p0;
|
||
Vec3 e1 = b - a;
|
||
Vec3 e2 = c - a;
|
||
Vec3 pvec = cross(dir, e2);
|
||
double det = dot(e1, pvec);
|
||
if (std::fabs(det) < 1e-12)
|
||
return false;
|
||
double invDet = 1.0 / det;
|
||
|
||
Vec3 tvec = p0 - a;
|
||
double u = dot(tvec, pvec) * invDet;
|
||
if (u < -1e-12 || u > 1.0 + 1e-12)
|
||
return false;
|
||
|
||
Vec3 qvec = cross(tvec, e1);
|
||
double v = dot(dir, qvec) * invDet;
|
||
if (v < -1e-12 || u + v > 1.0 + 1e-12)
|
||
return false;
|
||
|
||
double t = dot(e2, qvec) * invDet;
|
||
if (t < -1e-12 || t > 1.0 + 1e-12)
|
||
return false;
|
||
tOut = t;
|
||
return true;
|
||
}
|
||
|
||
static inline bool pointInTriangle3D(const Vec3 &p, const Vec3 &a, const Vec3 &b, const Vec3 &c) {
|
||
Vec3 n = cross(b - a, c - a);
|
||
Vec3 n0 = cross(b - a, p - a);
|
||
Vec3 n1 = cross(c - b, p - b);
|
||
Vec3 n2 = cross(a - c, p - c);
|
||
if (dot(n, n0) < -1e-12)
|
||
return false;
|
||
if (dot(n, n1) < -1e-12)
|
||
return false;
|
||
if (dot(n, n2) < -1e-12)
|
||
return false;
|
||
return true;
|
||
}
|
||
|
||
static inline bool triTriIntersect3D(const Vec3 &a0, const Vec3 &b0, const Vec3 &c0,
|
||
const Vec3 &a1, const Vec3 &b1, const Vec3 &c1) {
|
||
Vec3 mn0, mx0, mn1, mx1;
|
||
triAABB(a0, b0, c0, mn0, mx0);
|
||
triAABB(a1, b1, c1, mn1, mx1);
|
||
if (!aabbOverlap(mn0, mx0, mn1, mx1))
|
||
return false;
|
||
|
||
Plane p0 = planeFromTriangle(a0, b0, c0);
|
||
Plane p1 = planeFromTriangle(a1, b1, c1);
|
||
|
||
if (std::fabs(dot(p0.n, p1.n)) > 1.0 - 1e-7 && std::fabs(planeSignedDistance(p0, a1)) < 1e-7) {
|
||
Vec3 nn = p0.n;
|
||
int drop = 0;
|
||
double ax = std::fabs(nn.x), ay = std::fabs(nn.y), az = std::fabs(nn.z);
|
||
if (ay > ax && ay > az)
|
||
drop = 1;
|
||
else if (az > ax && az > ay)
|
||
drop = 2;
|
||
|
||
auto proj = [&](const Vec3 &v) -> Vec2 {
|
||
if (drop == 0)
|
||
return Vec2 { v.y, v.z };
|
||
if (drop == 1)
|
||
return Vec2 { v.x, v.z };
|
||
return Vec2 { v.x, v.y };
|
||
};
|
||
|
||
std::array<Vec2, 3> t0 { proj(a0), proj(b0), proj(c0) };
|
||
std::array<Vec2, 3> t1 { proj(a1), proj(b1), proj(c1) };
|
||
return triOverlap2D(t0, t1);
|
||
}
|
||
|
||
const Vec3 t0v[3] = { a0, b0, c0 };
|
||
const Vec3 t1v[3] = { a1, b1, c1 };
|
||
for (int i = 0; i < 3; i++) {
|
||
double t = 0;
|
||
if (segmentTriangleIntersect(t0v[i], t0v[(i + 1) % 3], a1, b1, c1, t))
|
||
return true;
|
||
if (segmentTriangleIntersect(t1v[i], t1v[(i + 1) % 3], a0, b0, c0, t))
|
||
return true;
|
||
}
|
||
|
||
if (pointInTriangle3D(a0, a1, b1, c1))
|
||
return true;
|
||
if (pointInTriangle3D(a1, a0, b0, c0))
|
||
return true;
|
||
return false;
|
||
}
|
||
|
||
struct Image {
|
||
int w = 0, h = 0;
|
||
std::vector<Vec3> pix;
|
||
|
||
Image(int ww, int hh) : w(ww), h(hh), pix((size_t)ww * (size_t)hh, Vec3 { 0, 0, 0 }) {
|
||
}
|
||
|
||
void blendOver(int x, int y, const Vec3 &src, double alpha) {
|
||
if (x < 0 || x >= w || y < 0 || y >= h)
|
||
return;
|
||
alpha = clamp01(alpha);
|
||
Vec3 dst = pix[(size_t)y * (size_t)w + (size_t)x];
|
||
Vec3 out = dst * (1.0 - alpha) + src * alpha;
|
||
pix[(size_t)y * (size_t)w + (size_t)x] = out;
|
||
}
|
||
|
||
void add(int x, int y, const Vec3 &src) {
|
||
if (x < 0 || x >= w || y < 0 || y >= h)
|
||
return;
|
||
Vec3 dst = pix[(size_t)y * (size_t)w + (size_t)x];
|
||
pix[(size_t)y * (size_t)w + (size_t)x] = Vec3 { dst.x + src.x, dst.y + src.y, dst.z + src.z };
|
||
}
|
||
|
||
void writePPM(const std::string &path) const {
|
||
std::ofstream out(path, std::ios::binary);
|
||
if (!out) {
|
||
std::cerr << "Failed to open output file: " << path << "\n";
|
||
return;
|
||
}
|
||
out << "P6\n"
|
||
<< w << " " << h << "\n255\n";
|
||
for (int y = 0; y < h; y++) {
|
||
for (int x = 0; x < w; x++) {
|
||
Vec3 c = pix[(size_t)y * (size_t)w + (size_t)x];
|
||
c.x = clamp01(c.x);
|
||
c.y = clamp01(c.y);
|
||
c.z = clamp01(c.z);
|
||
auto toByte = [](double v) -> unsigned char {
|
||
v = std::pow(clamp01(v), 1.0 / 2.2);
|
||
int iv = (int)std::lround(v * 255.0);
|
||
return (unsigned char)clampi(iv, 0, 255);
|
||
};
|
||
unsigned char rgb[3] = { toByte(c.x), toByte(c.y), toByte(c.z) };
|
||
out.write((char *)rgb, 3);
|
||
}
|
||
}
|
||
}
|
||
};
|
||
|
||
enum class MaterialType {
|
||
Curtain,
|
||
Diffuse,
|
||
Metal
|
||
};
|
||
|
||
struct Triangle {
|
||
int id = -1;
|
||
std::string name;
|
||
|
||
Vec3 p[3];
|
||
Vec2 uv[3];
|
||
|
||
MaterialType mat = MaterialType::Diffuse;
|
||
Vec3 baseColor { 1, 1, 1 };
|
||
|
||
Vec3 normal() const {
|
||
return normalize(cross(p[1] - p[0], p[2] - p[0]));
|
||
}
|
||
Vec3 centroid() const {
|
||
return (p[0] + p[1] + p[2]) / 3.0;
|
||
}
|
||
};
|
||
|
||
struct ProjectedVertex {
|
||
bool ok = false;
|
||
Vec3 onPlane;
|
||
double t = 0.0;
|
||
};
|
||
|
||
static inline ProjectedVertex projectPointToPlaneAlongOrigin(const Vec3 &origin, const Vec3 &v, const Plane &plane) {
|
||
Vec3 dir = v - origin;
|
||
double denom = dot(plane.n, dir);
|
||
if (std::fabs(denom) < 1e-12)
|
||
return ProjectedVertex { false, Vec3 {}, 0 };
|
||
double t = -(dot(plane.n, origin) + plane.d) / denom;
|
||
if (t <= 1e-9)
|
||
return ProjectedVertex { false, Vec3 {}, t };
|
||
Vec3 p = origin + dir * t;
|
||
return ProjectedVertex { true, p, t };
|
||
}
|
||
|
||
// 显式的“当前 viewport 在最终图片中的范围”
|
||
// 用屏幕UV三角形表达（更贴合你描述的“两个三角形幕布”与递归中“面片->面片”的映射）
|
||
using ScreenTri = std::array<Vec2, 3>;
|
||
|
||
static inline bool pointInScreenTri(const ScreenTri &tri, const Vec2 &uv) {
|
||
return pointInTri2D(uv, tri[0], tri[1], tri[2]);
|
||
}
|
||
|
||
static inline Vec2 uvFromPixelCenter(int x, int y, int w, int h) {
|
||
double u = ((double)x + 0.5) / (double)w;
|
||
double v = 1.0 - (((double)y + 0.5) / (double)h);
|
||
return Vec2 { u, v };
|
||
}
|
||
|
||
static inline std::array<Vec2, 3> projectedTriangleToViewport2D(const Basis2DOnPlane &basis,
|
||
const std::array<Vec3, 3> &proj) {
|
||
return { to2D(basis, proj[0]), to2D(basis, proj[1]), to2D(basis, proj[2]) };
|
||
}
|
||
|
||
static inline std::array<Vec2, 3> viewportTriangleTo2D(const Basis2DOnPlane &basis, const Triangle &viewport) {
|
||
return {
|
||
to2D(basis, viewport.p[0]),
|
||
to2D(basis, viewport.p[1]),
|
||
to2D(basis, viewport.p[2]),
|
||
};
|
||
}
|
||
|
||
static inline bool projectTriangleToViewport(const Triangle &tri,
|
||
const Vec3 &origin,
|
||
const Triangle &viewport,
|
||
const Basis2DOnPlane &viewportBasis,
|
||
const ScreenTri &viewportRegion,
|
||
std::array<Vec3, 3> &projOnViewportPlane,
|
||
ScreenTri &triScreenUV) {
|
||
Plane plane = planeFromTriangle(viewport.p[0], viewport.p[1], viewport.p[2]);
|
||
|
||
ProjectedVertex pv[3];
|
||
for (int i = 0; i < 3; i++) {
|
||
pv[i] = projectPointToPlaneAlongOrigin(origin, tri.p[i], plane);
|
||
if (!pv[i].ok)
|
||
return false;
|
||
projOnViewportPlane[i] = pv[i].onPlane;
|
||
}
|
||
|
||
auto proj2D = projectedTriangleToViewport2D(viewportBasis, projOnViewportPlane);
|
||
auto vp2D = viewportTriangleTo2D(viewportBasis, viewport);
|
||
if (!triOverlap2D(proj2D, vp2D))
|
||
return false;
|
||
|
||
// 用 viewport 顶点 <-> viewportRegion 的三点对应，建立“viewport平面 -> 屏幕UV”的仿射映射
|
||
Vec2 A2 = vp2D[0], B2 = vp2D[1], C2 = vp2D[2];
|
||
for (int i = 0; i < 3; i++) {
|
||
Vec3 bc = barycentric2D(proj2D[i], A2, B2, C2);
|
||
Vec2 uv = viewportRegion[0] * bc.x + viewportRegion[1] * bc.y + viewportRegion[2] * bc.z;
|
||
triScreenUV[i] = uv;
|
||
}
|
||
return true;
|
||
}
|
||
|
||
static inline double triAreaPixels(const ScreenTri &screenUV, int w, int h) {
|
||
Vec2 a = Vec2 { screenUV[0].x * w, screenUV[0].y * h };
|
||
Vec2 b = Vec2 { screenUV[1].x * w, screenUV[1].y * h };
|
||
Vec2 c = Vec2 { screenUV[2].x * w, screenUV[2].y * h };
|
||
double area2 = std::fabs(cross2(b - a, c - a));
|
||
return area2 * 0.5;
|
||
}
|
||
|
||
static inline Vec3 sampleProceduralTexture(const Triangle &tri, const Vec2 &uv) {
|
||
double u = uv.x, v = uv.y;
|
||
double s = 10.0;
|
||
int iu = (int)std::floor(u * s);
|
||
int iv = (int)std::floor(v * s);
|
||
bool checker = ((iu + iv) & 1) == 0;
|
||
|
||
Vec3 base = tri.baseColor;
|
||
if (tri.mat == MaterialType::Metal) {
|
||
double stripe = 0.6 + 0.4 * std::sin((u * 40.0 + v * 15.0) * 3.14159);
|
||
base = base * stripe;
|
||
} else {
|
||
double k = checker ? 1.0 : 0.85;
|
||
base = base * k;
|
||
}
|
||
return base;
|
||
}
|
||
|
||
static inline Vec3 shadeLambert(const Vec3 &color, const Vec3 &n) {
|
||
Vec3 lightDir = normalize(Vec3 { -0.35, 0.85, 0.25 });
|
||
double ndl = std::max(0.0, dot(n, lightDir));
|
||
double amb = 0.20;
|
||
double diff = 0.90 * ndl;
|
||
return color * (amb + diff);
|
||
}
|
||
|
||
static inline void rasterizeTriangleToImage(Image &img,
|
||
const ScreenTri &triScreenUV,
|
||
const Triangle &tri,
|
||
const ScreenTri &viewportRegion,
|
||
const Vec3 &throughput,
|
||
double alpha,
|
||
bool additive) {
|
||
// 强制只写入 viewportRegion 覆盖的屏幕区域
|
||
// triScreenUV 是“当前 tri 投影到当前 viewport 后，再映射到最终屏幕”的三角形
|
||
|
||
double minU = std::min({ triScreenUV[0].x, triScreenUV[1].x, triScreenUV[2].x });
|
||
double maxU = std::max({ triScreenUV[0].x, triScreenUV[1].x, triScreenUV[2].x });
|
||
double minV = std::min({ triScreenUV[0].y, triScreenUV[1].y, triScreenUV[2].y });
|
||
double maxV = std::max({ triScreenUV[0].y, triScreenUV[1].y, triScreenUV[2].y });
|
||
|
||
int x0 = clampi((int)std::floor(minU * img.w) - 1, 0, img.w - 1);
|
||
int x1 = clampi((int)std::ceil(maxU * img.w) + 1, 0, img.w - 1);
|
||
int y0 = clampi((int)std::floor((1.0 - maxV) * img.h) - 1, 0, img.h - 1);
|
||
int y1 = clampi((int)std::ceil((1.0 - minV) * img.h) + 1, 0, img.h - 1);
|
||
|
||
Vec2 a = triScreenUV[0], b = triScreenUV[1], c = triScreenUV[2];
|
||
Vec3 n = tri.normal();
|
||
|
||
for (int y = y0; y <= y1; y++) {
|
||
for (int x = x0; x <= x1; x++) {
|
||
Vec2 suv = uvFromPixelCenter(x, y, img.w, img.h);
|
||
|
||
// 关键：限制写入区域为当前 viewportRegion
|
||
if (!pointInScreenTri(viewportRegion, suv))
|
||
continue;
|
||
|
||
Vec3 bc = barycentric2D(suv, a, b, c);
|
||
if (bc.x < -1e-12 || bc.y < -1e-12 || bc.z < -1e-12)
|
||
continue;
|
||
|
||
Vec2 uv = tri.uv[0] * bc.x + tri.uv[1] * bc.y + tri.uv[2] * bc.z;
|
||
|
||
Vec3 tex = sampleProceduralTexture(tri, uv);
|
||
Vec3 lit = shadeLambert(tex, n);
|
||
Vec3 src = Vec3 { lit.x * throughput.x, lit.y * throughput.y, lit.z * throughput.z };
|
||
|
||
if (additive)
|
||
img.add(x, y, src * alpha);
|
||
else
|
||
img.blendOver(x, y, src, alpha);
|
||
}
|
||
}
|
||
}
|
||
|
||
struct RenderConfig {
|
||
int maxDepth = 3;
|
||
double minAreaPixels = 3.0;
|
||
};
|
||
|
||
static void renderViewport(const std::vector<Triangle> &scene,
|
||
const Vec3 &origin,
|
||
const Triangle &viewport,
|
||
const Basis2DOnPlane &viewportBasis,
|
||
const ScreenTri &viewportRegion,
|
||
Image &out,
|
||
const RenderConfig &cfg,
|
||
int depth,
|
||
const Vec3 &throughput,
|
||
int excludeId);
|
||
|
||
static inline double fresnelSchlick(double cosTheta, double f0) {
|
||
cosTheta = clamp01(cosTheta);
|
||
return f0 + (1.0 - f0) * std::pow(1.0 - cosTheta, 5.0);
|
||
}
|
||
|
||
static void renderTriangleWithTriangle(const std::vector<Triangle> &scene,
|
||
const Vec3 &origin,
|
||
const Triangle &viewport,
|
||
const Basis2DOnPlane &viewportBasis,
|
||
const ScreenTri &viewportRegion,
|
||
const Triangle &tri,
|
||
Image &out,
|
||
const RenderConfig &cfg,
|
||
int depth,
|
||
const Vec3 &throughput,
|
||
int excludeId) {
|
||
if (tri.id == excludeId)
|
||
return;
|
||
if (tri.mat == MaterialType::Curtain)
|
||
return;
|
||
|
||
std::array<Vec3, 3> projOnPlane {};
|
||
ScreenTri triScreenUV {};
|
||
if (!projectTriangleToViewport(tri, origin, viewport, viewportBasis, viewportRegion, projOnPlane, triScreenUV))
|
||
return;
|
||
|
||
double areaPix = triAreaPixels(triScreenUV, out.w, out.h);
|
||
if (areaPix < 0.25)
|
||
return;
|
||
|
||
if (tri.mat == MaterialType::Diffuse) {
|
||
// 漫反射：直接贴到最终屏幕，但写入范围必须受 viewportRegion 限制（已在 rasterize 内处理）
|
||
rasterizeTriangleToImage(out, triScreenUV, tri, viewportRegion, throughput, 1.0, false);
|
||
return;
|
||
}
|
||
|
||
if (tri.mat == MaterialType::Metal) {
|
||
// 金属：先贴自身底色，再递归把反射结果“写到它在最终屏幕上的 triScreenUV 区域里”
|
||
Vec3 n = tri.normal();
|
||
Vec3 viewDir = normalize(origin - tri.centroid());
|
||
double cosTheta = std::fabs(dot(n, viewDir));
|
||
double reflectK = 0.75;
|
||
double f0 = 0.90;
|
||
double F = fresnelSchlick(cosTheta, f0);
|
||
double refl = clamp01(reflectK * F);
|
||
|
||
rasterizeTriangleToImage(out, triScreenUV, tri, viewportRegion, throughput, 1.0, false);
|
||
|
||
if (depth >= cfg.maxDepth)
|
||
return;
|
||
if (areaPix < cfg.minAreaPixels)
|
||
return;
|
||
|
||
Plane triPlane = planeFromTriangle(tri.p[0], tri.p[1], tri.p[2]);
|
||
Vec3 reflectedOrigin = reflectPointAcrossPlane(origin, triPlane);
|
||
|
||
// 关键：下一级 viewport 就是 tri（世界空间），而它在最终图片中的区域就是 triScreenUV
|
||
const Triangle &childViewport = tri;
|
||
Basis2DOnPlane childBasis = makePlaneBasis(childViewport.p[0], childViewport.p[1], childViewport.p[2]);
|
||
ScreenTri childRegion = triScreenUV;
|
||
|
||
Vec3 throughputChild = Vec3 { throughput.x * refl, throughput.y * refl, throughput.z * refl };
|
||
|
||
renderViewport(scene, reflectedOrigin, childViewport, childBasis, childRegion, out, cfg, depth + 1, throughputChild, tri.id);
|
||
return;
|
||
}
|
||
}
|
||
|
||
static void renderViewport(const std::vector<Triangle> &scene,
|
||
const Vec3 &origin,
|
||
const Triangle &viewport,
|
||
const Basis2DOnPlane &viewportBasis,
|
||
const ScreenTri &viewportRegion,
|
||
Image &out,
|
||
const RenderConfig &cfg,
|
||
int depth,
|
||
const Vec3 &throughput,
|
||
int excludeId) {
|
||
struct Cand {
|
||
const Triangle *t;
|
||
double dist2;
|
||
};
|
||
std::vector<Cand> cands;
|
||
cands.reserve(scene.size());
|
||
|
||
for (const Triangle &tri : scene) {
|
||
if (tri.id == excludeId)
|
||
continue;
|
||
if (tri.mat == MaterialType::Curtain)
|
||
continue;
|
||
|
||
std::array<Vec3, 3> projOnPlane {};
|
||
ScreenTri triScreenUV {};
|
||
if (!projectTriangleToViewport(tri, origin, viewport, viewportBasis, viewportRegion, projOnPlane, triScreenUV))
|
||
continue;
|
||
|
||
Vec3 c = tri.centroid();
|
||
Vec3 d = c - origin;
|
||
double dist2 = dot(d, d);
|
||
cands.push_back(Cand { &tri, dist2 });
|
||
}
|
||
|
||
std::sort(cands.begin(), cands.end(), [](const Cand &a, const Cand &b) {
|
||
return a.dist2 > b.dist2;
|
||
});
|
||
|
||
for (const Cand &c : cands) {
|
||
renderTriangleWithTriangle(scene, origin, viewport, viewportBasis, viewportRegion, *c.t, out, cfg, depth, throughput, excludeId);
|
||
}
|
||
}
|
||
|
||
struct Camera {
|
||
Vec3 origin;
|
||
Triangle curtainA;
|
||
Triangle curtainB;
|
||
|
||
void render(const std::vector<Triangle> &scene, Image &out) const {
|
||
RenderConfig cfg;
|
||
cfg.maxDepth = 3;
|
||
cfg.minAreaPixels = 3.0;
|
||
|
||
// Curtain A：viewportRegion 就是它本身的 uv（三角形覆盖屏幕的一半）
|
||
{
|
||
const Triangle &viewport = curtainA;
|
||
Basis2DOnPlane basis = makePlaneBasis(viewport.p[0], viewport.p[1], viewport.p[2]);
|
||
ScreenTri region = { viewport.uv[0], viewport.uv[1], viewport.uv[2] };
|
||
renderViewport(scene, origin, viewport, basis, region, out, cfg, 0, Vec3 { 1, 1, 1 }, -1);
|
||
}
|
||
|
||
// Curtain B
|
||
{
|
||
const Triangle &viewport = curtainB;
|
||
Basis2DOnPlane basis = makePlaneBasis(viewport.p[0], viewport.p[1], viewport.p[2]);
|
||
ScreenTri region = { viewport.uv[0], viewport.uv[1], viewport.uv[2] };
|
||
renderViewport(scene, origin, viewport, basis, region, out, cfg, 0, Vec3 { 1, 1, 1 }, -1);
|
||
}
|
||
}
|
||
};
|
||
|
||
static inline Triangle makeTri(int id, const std::string &name,
|
||
const Vec3 &a, const Vec3 &b, const Vec3 &c,
|
||
const Vec2 &ua, const Vec2 &ub, const Vec2 &uc,
|
||
MaterialType mat, const Vec3 &color) {
|
||
Triangle t;
|
||
t.id = id;
|
||
t.name = name;
|
||
t.p[0] = a;
|
||
t.p[1] = b;
|
||
t.p[2] = c;
|
||
t.uv[0] = ua;
|
||
t.uv[1] = ub;
|
||
t.uv[2] = uc;
|
||
t.mat = mat;
|
||
t.baseColor = color;
|
||
return t;
|
||
}
|
||
|
||
static inline void addQuad(std::vector<Triangle> &out, int &nextId, const std::string &name,
|
||
const Vec3 &a, const Vec3 &b, const Vec3 &c, const Vec3 &d,
|
||
const Vec2 &ua, const Vec2 &ub, const Vec2 &uc, const Vec2 &ud,
|
||
MaterialType mat, const Vec3 &color) {
|
||
out.push_back(makeTri(nextId++, name + "_t0", a, b, c, ua, ub, uc, mat, color));
|
||
out.push_back(makeTri(nextId++, name + "_t1", a, c, d, ua, uc, ud, mat, color));
|
||
}
|
||
|
||
static inline void addBox(std::vector<Triangle> &out, int &nextId, const std::string &name,
|
||
const Vec3 &mn, const Vec3 &mx,
|
||
MaterialType mat, const Vec3 &color) {
|
||
Vec3 p000 { mn.x, mn.y, mn.z };
|
||
Vec3 p001 { mn.x, mn.y, mx.z };
|
||
Vec3 p010 { mn.x, mx.y, mn.z };
|
||
Vec3 p011 { mn.x, mx.y, mx.z };
|
||
Vec3 p100 { mx.x, mn.y, mn.z };
|
||
Vec3 p101 { mx.x, mn.y, mx.z };
|
||
Vec3 p110 { mx.x, mx.y, mn.z };
|
||
Vec3 p111 { mx.x, mx.y, mx.z };
|
||
|
||
Vec2 uv00 { 0, 0 }, uv10 { 1, 0 }, uv11 { 1, 1 }, uv01 { 0, 1 };
|
||
|
||
addQuad(out, nextId, name + "_front", p001, p101, p111, p011, uv00, uv10, uv11, uv01, mat, color);
|
||
addQuad(out, nextId, name + "_back", p100, p000, p010, p110, uv00, uv10, uv11, uv01, mat, color);
|
||
addQuad(out, nextId, name + "_left", p000, p001, p011, p010, uv00, uv10, uv11, uv01, mat, color);
|
||
addQuad(out, nextId, name + "_right", p101, p100, p110, p111, uv00, uv10, uv11, uv01, mat, color);
|
||
addQuad(out, nextId, name + "_top", p010, p011, p111, p110, uv00, uv10, uv11, uv01, mat, color);
|
||
addQuad(out, nextId, name + "_bottom", p000, p100, p101, p001, uv00, uv10, uv11, uv01, mat, color);
|
||
}
|
||
|
||
static std::vector<Triangle> buildCornellScene() {
|
||
std::vector<Triangle> scene;
|
||
int nextId = 0;
|
||
|
||
Vec3 mn { -1, -1, 0 };
|
||
Vec3 mx { 1, 1, 2 };
|
||
|
||
Vec2 uv00 { 0, 0 }, uv10 { 1, 0 }, uv11 { 1, 1 }, uv01 { 0, 1 };
|
||
|
||
addQuad(scene, nextId, "wall_back",
|
||
Vec3 { mn.x, mn.y, mn.z }, Vec3 { mx.x, mn.y, mn.z }, Vec3 { mx.x, mx.y, mn.z }, Vec3 { mn.x, mx.y, mn.z },
|
||
uv00, uv10, uv11, uv01, MaterialType::Diffuse, Vec3 { 0.95, 0.95, 0.95 });
|
||
|
||
addQuad(scene, nextId, "wall_left",
|
||
Vec3 { mn.x, mn.y, mx.z }, Vec3 { mn.x, mn.y, mn.z }, Vec3 { mn.x, mx.y, mn.z }, Vec3 { mn.x, mx.y, mx.z },
|
||
uv00, uv10, uv11, uv01, MaterialType::Diffuse, Vec3 { 0.90, 0.25, 0.25 });
|
||
|
||
addQuad(scene, nextId, "wall_right",
|
||
Vec3 { mx.x, mn.y, mn.z }, Vec3 { mx.x, mn.y, mx.z }, Vec3 { mx.x, mx.y, mx.z }, Vec3 { mx.x, mx.y, mn.z },
|
||
uv00, uv10, uv11, uv01, MaterialType::Diffuse, Vec3 { 0.25, 0.90, 0.25 });
|
||
|
||
addQuad(scene, nextId, "floor",
|
||
Vec3 { mn.x, mn.y, mx.z }, Vec3 { mx.x, mn.y, mx.z }, Vec3 { mx.x, mn.y, mn.z }, Vec3 { mn.x, mn.y, mn.z },
|
||
uv00, uv10, uv11, uv01, MaterialType::Diffuse, Vec3 { 0.95, 0.95, 0.95 });
|
||
|
||
addQuad(scene, nextId, "ceiling",
|
||
Vec3 { mn.x, mx.y, mn.z }, Vec3 { mx.x, mx.y, mn.z }, Vec3 { mx.x, mx.y, mx.z }, Vec3 { mn.x, mx.y, mx.z },
|
||
uv00, uv10, uv11, uv01, MaterialType::Diffuse, Vec3 { 0.95, 0.95, 0.95 });
|
||
|
||
// 蓝金属盒
|
||
{
|
||
Vec3 bmn { -0.75, -1.0, 0.75 };
|
||
Vec3 bmx { -0.15, -0.40, 1.35 };
|
||
addBox(scene, nextId, "box_blue_metal", bmn, bmx, MaterialType::Metal, Vec3 { 0.20, 0.40, 0.95 });
|
||
}
|
||
|
||
// 黄金属盒
|
||
{
|
||
Vec3 ymn { 0.15, -1.0, 1.10 };
|
||
Vec3 ymx { 0.70, -0.20, 1.70 };
|
||
addBox(scene, nextId, "box_yellow_metal", ymn, ymx, MaterialType::Metal, Vec3 { 0.95, 0.85, 0.20 });
|
||
}
|
||
|
||
// 小漫反射柱（辅助反射观感）
|
||
{
|
||
Vec3 dmn { -0.10, -1.0, 1.55 };
|
||
Vec3 dmx { 0.10, -0.70, 1.75 };
|
||
addBox(scene, nextId, "diffuse_pillar", dmn, dmx, MaterialType::Diffuse, Vec3 { 0.85, 0.85, 0.90 });
|
||
}
|
||
|
||
return scene;
|
||
}
|
||
|
||
int main() {
|
||
const int W = 800;
|
||
const int H = 800;
|
||
|
||
Image img(W, H);
|
||
|
||
Camera cam;
|
||
cam.origin = Vec3 { 0.0, 0.0, 3.0 };
|
||
|
||
// Curtain（两个三角形）
|
||
Vec3 s0 { -1.1, -1.1, 2.5 };
|
||
Vec3 s1 { 1.1, -1.1, 2.5 };
|
||
Vec3 s2 { 1.1, 1.1, 2.5 };
|
||
Vec3 s3 { -1.1, 1.1, 2.5 };
|
||
|
||
cam.curtainA = makeTri(-100, "curtainA",
|
||
s0, s1, s2,
|
||
Vec2 { 0, 0 }, Vec2 { 1, 0 }, Vec2 { 1, 1 },
|
||
MaterialType::Curtain, Vec3 { 0, 0, 0 });
|
||
cam.curtainB = makeTri(-101, "curtainB",
|
||
s0, s2, s3,
|
||
Vec2 { 0, 0 }, Vec2 { 1, 1 }, Vec2 { 0, 1 },
|
||
MaterialType::Curtain, Vec3 { 0, 0, 0 });
|
||
|
||
auto scene = buildCornellScene();
|
||
|
||
// 只是证明 tri-tri 相交存在，不影响渲染
|
||
if (scene.size() >= 2) {
|
||
(void)triTriIntersect3D(scene[0].p[0], scene[0].p[1], scene[0].p[2],
|
||
scene[1].p[0], scene[1].p[1], scene[1].p[2]);
|
||
}
|
||
|
||
cam.render(scene, img);
|
||
img.writePPM("out.ppm");
|
||
|
||
std::cout << "Wrote out.ppm (" << W << "x" << H << ")\n";
|
||
return 0;
|
||
}
|