#include <iostream>
#include <vector>
#include <cmath>
#include <algorithm>
#include <fstream>
#include <limits>
#include <memory>
#include <array>

// ==================== 基础数学结构 ====================

struct Vec3 {
    double x, y, z;
    
    Vec3() : x(0), y(0), z(0) {}
    Vec3(double x, double y, double z) : 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*(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+=(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 normalized() const {
        double len = length();
        if (len < 1e-10) return Vec3(0, 0, 0);
        return *this / len;
    }
    
    // 关于平面对称点
    static Vec3 reflect(const Vec3& point, const Vec3& planePoint, const Vec3& planeNormal) {
        Vec3 n = planeNormal.normalized();
        double d = (point - planePoint).dot(n);
        return point - n * (2 * d);
    }
};

Vec3 operator*(double t, const Vec3& v) { return v * t; }

// 颜色结构（RGB，0-1范围）
struct Color {
    double r, g, b;
    
    Color() : r(0), g(0), b(0) {}
    Color(double r, double g, double b) : 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*(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+=(const Color& c) { r += c.r; g += c.g; b += c.b; return *this; }
    
    Color clamped() 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))
        );
    }
    
    static Color lerp(const Color& a, const Color& b, double t) {
        return Color(a.r + (b.r - a.r) * t, a.g + (b.g - a.g) * t, a.b + (b.b - a.b) * t);
    }
};

// ==================== 纹理类 ====================

class Texture {
public:
    int width, height;
    std::vector<Color> pixels;
    
    Texture() : width(0), height(0) {}
    Texture(int w, int h) : width(w), height(h), pixels(w * h) {}
    Texture(int w, int h, const Color& fillColor) : width(w), height(h), pixels(w * h, fillColor) {}
    
    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) return;
        pixels[y * width + x] = c;
    }
    
    // 双线性插值采样（UV坐标0-1）
    Color sample(double u, double v) const {
        if (width == 0 || height == 0) return Color(0, 0, 0);
        
        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;
        int y0 = (int)fy;
        int x1 = std::min(x0 + 1, width - 1);
        int y1 = std::min(y0 + 1, height - 1);
        
        double tx = fx - x0;
        double 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 = Color::lerp(c00, c10, tx);
        Color c1 = Color::lerp(c01, c11, tx);
        
        return Color::lerp(c0, c1, ty);
    }
    
    // 在指定像素位置混合颜色（用于叠加）
    void blendPixel(int x, int y, const Color& c, double alpha = 1.0) {
        if (x < 0 || x >= width || y < 0 || y >= height) return;
        Color existing = getPixel(x, y);
        Color blended = Color(
            existing.r * (1 - alpha) + c.r * alpha,
            existing.g * (1 - alpha) + c.g * alpha,
            existing.b * (1 - alpha) + c.b * alpha
        );
        setPixel(x, y, blended);
    }
};

// ==================== 材质类型 ====================

enum class MaterialType {
    Diffuse,      // 漫反射
    Reflective,   // 镜面反射
    Emissive      // 发光体
};

struct Material {
    MaterialType type;
    Color baseColor;
    double reflectivity;  // 0-1，反射率
    
    Material() : type(MaterialType::Diffuse), baseColor(0.8, 0.8, 0.8), reflectivity(0) {}
    Material(MaterialType t, const Color& c, double refl = 0.9) 
        : type(t), baseColor(c), reflectivity(refl) {}
};

// ==================== 三角形类 ====================

class Triangle {
public:
    Vec3 v0, v1, v2;  // 三个顶点
    Vec3 normal;       // 法向量
    Material material;
    Texture* texture;  // 可选的纹理
    
    // UV坐标
    Vec3 uv0, uv1, uv2;
    
    Triangle() : texture(nullptr) {
        uv0 = Vec3(0, 0, 0);
        uv1 = Vec3(1, 0, 0);
        uv2 = Vec3(0, 1, 0);
    }
    
    Triangle(const Vec3& a, const Vec3& b, const Vec3& c, const Material& mat = Material())
        : v0(a), v1(b), v2(c), material(mat), texture(nullptr) {
        normal = (v1 - v0).cross(v2 - v0).normalized();
        uv0 = Vec3(0, 0, 0);
        uv1 = Vec3(1, 0, 0);
        uv2 = Vec3(0, 1, 0);
    }
    
    void setUV(const Vec3& u0, const Vec3& u1, const Vec3& u2) {
        uv0 = u0; uv1 = u1; uv2 = u2;
    }
    
    // 获取三角形中心
    Vec3 center() const {
        return (v0 + v1 + v2) / 3.0;
    }
    
    // 获取三角形面积
    double area() const {
        return (v1 - v0).cross(v2 - v0).length() * 0.5;
    }
    
    // 计算重心坐标
    bool barycentricCoords(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;
    }
    
    // 从重心坐标获取UV
    Vec3 getUVFromBarycentric(double u, double v, double w) const {
        return Vec3(
            u * uv0.x + v * uv1.x + w * uv2.x,
            u * uv0.y + v * uv1.y + w * uv2.y,
            0
        );
    }
    
    // 射线与三角形相交测试（Möller–Trumbore算法）
    bool rayIntersect(const Vec3& origin, const Vec3& dir, double& t, double& u, double& v) const {
        const double EPSILON = 1e-8;
        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;
    }
    
    // 获取指定UV处的颜色
    Color getColorAtUV(double u, double v) const {
        if (texture != nullptr) {
            return texture->sample(u, v);
        }
        return material.baseColor;
    }
};

// ==================== 视锥体类（由原点和三角形viewport组成） ====================

class Frustum {
public:
    Vec3 apex;           // 视锥体顶点（相机原点）
    Triangle viewport;   // 底面三角形
    
    // 四个平面（侧面3个 + 底面1个）
    // 每个平面由法向量和平面上的一点定义
    std::array<Vec3, 4> planeNormals;
    std::array<Vec3, 4> planePoints;
    
    Frustum() {}
    
    Frustum(const Vec3& origin, const Triangle& vp) : apex(origin), viewport(vp) {
        buildPlanes();
    }
    
    void buildPlanes() {
        // 三个侧面
        Vec3 edge0 = viewport.v1 - viewport.v0;
        Vec3 edge1 = viewport.v2 - viewport.v1;
        Vec3 edge2 = viewport.v0 - viewport.v2;
        
        Vec3 toApex0 = apex - viewport.v0;
        Vec3 toApex1 = apex - viewport.v1;
        Vec3 toApex2 = apex - viewport.v2;
        
        // 侧面0: v0-v1-apex
        planeNormals[0] = edge0.cross(toApex0).normalized();
        planePoints[0] = viewport.v0;
        
        // 侧面1: v1-v2-apex
        planeNormals[1] = edge1.cross(toApex1).normalized();
        planePoints[1] = viewport.v1;
        
        // 侧面2: v2-v0-apex
        planeNormals[2] = edge2.cross(toApex2).normalized();
        planePoints[2] = viewport.v2;
        
        // 底面（viewport平面）
        planeNormals[3] = viewport.normal;
        planePoints[3] = viewport.v0;
        
        // 确保法向量朝向视锥体内部
        Vec3 center = (viewport.v0 + viewport.v1 + viewport.v2) / 3.0;
        Vec3 frustumCenter = (center + apex) / 2.0;
        
        for (int i = 0; i < 3; ++i) {
            Vec3 toCenter = frustumCenter - planePoints[i];
            if (planeNormals[i].dot(toCenter) < 0) {
                planeNormals[i] = planeNormals[i] * (-1);
            }
        }
        
        // 底面法向量应该指向apex方向
        Vec3 toApex = apex - planePoints[3];
        if (planeNormals[3].dot(toApex) < 0) {
            planeNormals[3] = planeNormals[3] * (-1);
        }
    }
    
    // 检测点是否在视锥体内
    bool containsPoint(const Vec3& p) const {
        for (int i = 0; i < 4; ++i) {
            Vec3 toPoint = p - planePoints[i];
            if (planeNormals[i].dot(toPoint) < -1e-6) {
                return false;
            }
        }
        return true;
    }
    
    // 检测三角形是否与视锥体相交或被包含
    bool intersectsTriangle(const Triangle& tri) const {
        // 简化检测：检查三角形的任意顶点是否在视锥体内，
        // 或者视锥体的任意边是否与三角形相交
        
        // 检查三角形顶点
        if (containsPoint(tri.v0) || containsPoint(tri.v1) || containsPoint(tri.v2)) {
            return true;
        }
        
        // 检查视锥体边与三角形的相交
        std::vector<std::pair<Vec3, Vec3>> frustumEdges = {
            {apex, viewport.v0},
            {apex, viewport.v1},
            {apex, viewport.v2},
            {viewport.v0, viewport.v1},
            {viewport.v1, viewport.v2},
            {viewport.v2, viewport.v0}
        };
        
        for (const auto& edge : frustumEdges) {
            Vec3 dir = edge.second - edge.first;
            double t, u, v;
            if (tri.rayIntersect(edge.first, dir.normalized(), t, u, v)) {
                if (t >= 0 && t <= dir.length()) {
                    return true;
                }
            }
        }
        
        // 检查三角形边与视锥体平面的相交
        std::vector<std::pair<Vec3, Vec3>> triEdges = {
            {tri.v0, tri.v1},
            {tri.v1, tri.v2},
            {tri.v2, tri.v0}
        };
        
        for (const auto& edge : triEdges) {
            Vec3 dir = edge.second - edge.first;
            double t, u, v;
            if (viewport.rayIntersect(edge.first, dir.normalized(), t, u, v)) {
                if (t >= 0 && t <= dir.length()) {
                    return true;
                }
            }
        }
        
        return false;
    }
};

// ==================== 前向声明 ====================

class Scene;
Texture renderTriangleWithTriangle(
    const std::vector<Triangle*>& triangles,
    const Vec3& cameraOrigin,
    const Triangle& currentTriangle,
    int estimatedWidth,
    int estimatedHeight,
    int depth,
    int maxDepth,
    const Scene& scene
);

// ==================== 场景类 ====================

class Scene {
public:
    std::vector<Triangle> triangles;
    Color ambientLight;
    Vec3 lightPosition;
    Color lightColor;
    
    Scene() : ambientLight(0.1, 0.1, 0.1), lightPosition(0, 1.9, 0), lightColor(1, 1, 1) {}
    
    void addTriangle(const Triangle& tri) {
        triangles.push_back(tri);
    }
    
    // 添加四边形（分解为两个三角形）
    void addQuad(const Vec3& v0, const Vec3& v1, const Vec3& v2, const Vec3& v3, const Material& mat) {
        Triangle t1(v0, v1, v2, mat);
        Triangle t2(v0, v2, v3, mat);
        
        // 设置UV坐标
        t1.setUV(Vec3(0, 0, 0), Vec3(1, 0, 0), Vec3(1, 1, 0));
        t2.setUV(Vec3(0, 0, 0), Vec3(1, 1, 0), Vec3(0, 1, 0));
        
        triangles.push_back(t1);
        triangles.push_back(t2);
    }
    
    // 添加盒子
    void addBox(const Vec3& minCorner, const Vec3& maxCorner, const Material& mat) {
        Vec3 v000 = minCorner;
        Vec3 v111 = maxCorner;
        Vec3 v100 = Vec3(maxCorner.x, minCorner.y, minCorner.z);
        Vec3 v010 = Vec3(minCorner.x, maxCorner.y, minCorner.z);
        Vec3 v001 = Vec3(minCorner.x, minCorner.y, maxCorner.z);
        Vec3 v110 = Vec3(maxCorner.x, maxCorner.y, minCorner.z);
        Vec3 v101 = Vec3(maxCorner.x, minCorner.y, maxCorner.z);
        Vec3 v011 = Vec3(minCorner.x, maxCorner.y, maxCorner.z);
        
        // 前面 (z = max)
        addQuad(v001, v101, v111, v011, mat);
        // 后面 (z = min)
        addQuad(v100, v000, v010, v110, mat);
        // 左面 (x = min)
        addQuad(v000, v001, v011, v010, mat);
        // 右面 (x = max)
        addQuad(v101, v100, v110, v111, mat);
        // 顶面 (y = max)
        addQuad(v010, v011, v111, v110, mat);
        // 底面 (y = min)
        addQuad(v000, v100, v101, v001, mat);
    }
    
    std::vector<Triangle*> getTrianglePointers() {
        std::vector<Triangle*> ptrs;
        for (auto& tri : triangles) {
            ptrs.push_back(&tri);
        }
        return ptrs;
    }
};

// ==================== 工具函数 ====================

// 将点从相机原点投影到目标平面上
Vec3 projectPointToPlane(const Vec3& origin, const Vec3& point, const Vec3& planePoint, const Vec3& planeNormal) {
    Vec3 dir = (point - origin).normalized();
    double denom = dir.dot(planeNormal);
    if (std::abs(denom) < 1e-10) return point; // 平行
    
    double t = (planePoint - origin).dot(planeNormal) / denom;
    return origin + dir * t;
}

// 将三角形的纹理变换并绘制到目标纹理上
void drawTransformedTriangle(
    Texture& destTexture,
    const Triangle& destTriangle,  // 目标三角形（viewport）
    const Triangle& srcTriangle,   // 源三角形
    const Texture& srcTexture,     // 源纹理
    const Vec3& cameraOrigin       // 相机原点
) {
    // 计算源三角形三个顶点投影到目标三角形平面上的位置
    Vec3 proj0 = projectPointToPlane(cameraOrigin, srcTriangle.v0, destTriangle.v0, destTriangle.normal);
    Vec3 proj1 = projectPointToPlane(cameraOrigin, srcTriangle.v1, destTriangle.v0, destTriangle.normal);
    Vec3 proj2 = projectPointToPlane(cameraOrigin, srcTriangle.v2, destTriangle.v0, destTriangle.normal);
    
    // 将投影点转换为目标三角形的重心坐标
    double u0, v0, w0, u1, v1, w1, u2, v2, w2;
    destTriangle.barycentricCoords(proj0, u0, v0, w0);
    destTriangle.barycentricCoords(proj1, u1, v1, w1);
    destTriangle.barycentricCoords(proj2, u2, v2, w2);
    
    // 转换为纹理坐标
    Vec3 texCoord0 = destTriangle.getUVFromBarycentric(u0, v0, w0);
    Vec3 texCoord1 = destTriangle.getUVFromBarycentric(u1, v1, w1);
    Vec3 texCoord2 = destTriangle.getUVFromBarycentric(u2, v2, w2);
    
    // 在目标纹理上栅格化源三角形
    // 计算边界框
    double minU = std::min({texCoord0.x, texCoord1.x, texCoord2.x});
    double maxU = std::max({texCoord0.x, texCoord1.x, texCoord2.x});
    double minV = std::min({texCoord0.y, texCoord1.y, texCoord2.y});
    double maxV = std::max({texCoord0.y, texCoord1.y, texCoord2.y});
    
    int startX = std::max(0, (int)(minU * destTexture.width) - 1);
    int endX = std::min(destTexture.width - 1, (int)(maxU * destTexture.width) + 1);
    int startY = std::max(0, (int)(minV * destTexture.height) - 1);
    int endY = std::min(destTexture.height - 1, (int)(maxV * destTexture.height) + 1);
    
    // 使用重心坐标进行纹理映射
    for (int py = startY; py <= endY; ++py) {
        for (int px = startX; px <= endX; ++px) {
            double u = (px + 0.5) / destTexture.width;
            double v = (py + 0.5) / destTexture.height;
            
            // 检查点是否在投影三角形内（使用2D重心坐标）
            Vec3 p(u, v, 0);
            Vec3 a(texCoord0.x, texCoord0.y, 0);
            Vec3 b(texCoord1.x, texCoord1.y, 0);
            Vec3 c(texCoord2.x, texCoord2.y, 0);
            
            Vec3 v0v = b - a;
            Vec3 v1v = c - a;
            Vec3 v2v = p - a;
            
            double d00 = v0v.x * v0v.x + v0v.y * v0v.y;
            double d01 = v0v.x * v1v.x + v0v.y * v1v.y;
            double d11 = v1v.x * v1v.x + v1v.y * v1v.y;
            double d20 = v2v.x * v0v.x + v2v.y * v0v.y;
            double d21 = v2v.x * v1v.x + v2v.y * v1v.y;
            
            double denom = d00 * d11 - d01 * d01;
            if (std::abs(denom) < 1e-10) continue;
            
            double baryV = (d11 * d20 - d01 * d21) / denom;
            double baryW = (d00 * d21 - d01 * d20) / denom;
            double baryU = 1.0 - baryV - baryW;
            
            // 检查是否在三角形内
            if (baryU >= -0.001 && baryV >= -0.001 && baryW >= -0.001) {
                // 计算源纹理的UV坐标
                double srcU = baryU * srcTriangle.uv0.x + baryV * srcTriangle.uv1.x + baryW * srcTriangle.uv2.x;
                double srcV = baryU * srcTriangle.uv0.y + baryV * srcTriangle.uv1.y + baryW * srcTriangle.uv2.y;
                
                Color srcColor = srcTexture.sample(srcU, srcV);
                destTexture.setPixel(px, py, srcColor);
            }
        }
    }
}

// 计算三角形投影到viewport上的近似像素面积
double estimateProjectedArea(const Triangle& tri, const Vec3& cameraOrigin, const Triangle& viewport, int viewportWidth, int viewportHeight) {
    Vec3 proj0 = projectPointToPlane(cameraOrigin, tri.v0, viewport.v0, viewport.normal);
    Vec3 proj1 = projectPointToPlane(cameraOrigin, tri.v1, viewport.v0, viewport.normal);
    Vec3 proj2 = projectPointToPlane(cameraOrigin, tri.v2, viewport.v0, viewport.normal);
    
    double u0, v0, w0, u1, v1, w1, u2, v2, w2;
    viewport.barycentricCoords(proj0, u0, v0, w0);
    viewport.barycentricCoords(proj1, u1, v1, w1);
    viewport.barycentricCoords(proj2, u2, v2, w2);
    
    Vec3 tc0 = viewport.getUVFromBarycentric(u0, v0, w0);
    Vec3 tc1 = viewport.getUVFromBarycentric(u1, v1, w1);
    Vec3 tc2 = viewport.getUVFromBarycentric(u2, v2, w2);
    
    // 计算2D三角形面积
    double area = 0.5 * std::abs(
        (tc1.x - tc0.x) * (tc2.y - tc0.y) - (tc2.x - tc0.x) * (tc1.y - tc0.y)
    );
    
    return area * viewportWidth * viewportHeight;
}

// ==================== 核心渲染函数 ====================

Texture renderTriangleWithTriangle(
    const std::vector<Triangle*>& triangles,
    const Vec3& cameraOrigin,
    const Triangle& currentTriangle,
    int estimatedWidth,
    int estimatedHeight,
    int depth,
    int maxDepth,
    const Scene& scene
) {
    // 检查终止条件
    if (depth >= maxDepth || estimatedWidth < 2 || estimatedHeight < 2) {
        // 返回基础颜色纹理
        Texture result(std::max(1, estimatedWidth), std::max(1, estimatedHeight), currentTriangle.material.baseColor);
        return result;
    }
    
    // 如果是漫反射材质，直接返回基础颜色
    if (currentTriangle.material.type == MaterialType::Diffuse) {
        Texture result(estimatedWidth, estimatedHeight, currentTriangle.material.baseColor);
        
        // 添加简单的光照计算
        Vec3 toLight = (scene.lightPosition - currentTriangle.center()).normalized();
        double diffuse = std::max(0.0, currentTriangle.normal.dot(toLight));
        
        Color litColor = currentTriangle.material.baseColor * (0.3 + 0.7 * diffuse);
        for (int y = 0; y < estimatedHeight; ++y) {
            for (int x = 0; x < estimatedWidth; ++x) {
                result.setPixel(x, y, litColor);
            }
        }
        
        return result;
    }
    
    // 如果是发光材质，返回发光颜色
    if (currentTriangle.material.type == MaterialType::Emissive) {
        Texture result(estimatedWidth, estimatedHeight, currentTriangle.material.baseColor);
        return result;
    }
    
    // 镜面反射材质
    // 初始化当前面片的纹理（使用基础颜色）
    Texture currentTexture(estimatedWidth, estimatedHeight, currentTriangle.material.baseColor * 0.1);
    
    // 计算反射后的相机原点（关于当前面片对称）
    Vec3 reflectedOrigin = Vec3::reflect(cameraOrigin, currentTriangle.center(), currentTriangle.normal);
    
    // 构建视锥体
    Frustum frustum(reflectedOrigin, currentTriangle);
    
    // 收集与视锥体相交的三角形
    struct TriangleDistance {
        Triangle* tri;
        double distance;
        
        bool operator<(const TriangleDistance& other) const {
            return distance > other.distance; // 由远到近
        }
    };
    
    std::vector<TriangleDistance> intersectedTriangles;
    
    for (Triangle* tri : triangles) {
        // 跳过当前三角形
        if (tri->v0.x == currentTriangle.v0.x && tri->v0.y == currentTriangle.v0.y && tri->v0.z == currentTriangle.v0.z &&
            tri->v1.x == currentTriangle.v1.x && tri->v1.y == currentTriangle.v1.y && tri->v1.z == currentTriangle.v1.z &&
            tri->v2.x == currentTriangle.v2.x && tri->v2.y == currentTriangle.v2.y && tri->v2.z == currentTriangle.v2.z) {
            continue;
        }
        
        // 检查三角形是否在视锥体的"前方"（从反射原点看去）
        Vec3 toTriCenter = tri->center() - reflectedOrigin;
        Vec3 viewDir = (currentTriangle.center() - reflectedOrigin).normalized();
        
        if (toTriCenter.dot(viewDir) <= 0) {
            continue; // 三角形在视锥体后方
        }
        
        if (frustum.intersectsTriangle(*tri)) {
            double dist = (tri->center() - reflectedOrigin).length();
            intersectedTriangles.push_back({tri, dist});
        }
    }
    
    // 按距离排序（由远到近）
    std::sort(intersectedTriangles.begin(), intersectedTriangles.end());
    
    // 遍历并渲染每个相交的三角形
    for (const auto& td : intersectedTriangles) {
        Triangle* tri = td.tri;
        
        // 估计该三角形投影到当前面片上的像素大小
        double projectedArea = estimateProjectedArea(*tri, reflectedOrigin, currentTriangle, estimatedWidth, estimatedHeight);
        int subWidth = std::max(2, (int)std::sqrt(projectedArea));
        int subHeight = subWidth;
        
        // 递归获取该三角形的纹理
        Texture subTexture = renderTriangleWithTriangle(
            triangles, reflectedOrigin, *tri, subWidth, subHeight, depth + 1, maxDepth, scene
        );
        
        // 创建临时三角形用于绘制（带有获取的纹理）
        Triangle tempTri = *tri;
        tempTri.texture = &subTexture;
        
        // 将该三角形的纹理变换并绘制到当前纹理上
        drawTransformedTriangle(currentTexture, currentTriangle, *tri, subTexture, reflectedOrigin);
    }
    
    // 混合基础颜色和反射结果
    double refl = currentTriangle.material.reflectivity;
    for (int y = 0; y < estimatedHeight; ++y) {
        for (int x = 0; x < estimatedWidth; ++x) {
            Color reflected = currentTexture.getPixel(x, y);
            Color base = currentTriangle.material.baseColor * 0.1;
            Color mixed = Color(
                base.r * (1 - refl) + reflected.r * refl,
                base.g * (1 - refl) + reflected.g * refl,
                base.b * (1 - refl) + reflected.b * refl
            );
            currentTexture.setPixel(x, y, mixed);
        }
    }
    
    return currentTexture;
}

// ==================== 相机类 ====================

class Camera {
public:
    Vec3 position;
    Vec3 lookAt;
    Vec3 up;
    double fov;
    int width, height;
    
    // Viewport三角形
    Triangle viewportTri1, viewportTri2;
    
    Camera(const Vec3& pos, const Vec3& look, const Vec3& upDir, double fieldOfView, int w, int h)
        : position(pos), lookAt(look), up(upDir), fov(fieldOfView), width(w), height(h) {
        setupViewport();
    }
    
    void setupViewport() {
        Vec3 forward = (lookAt - position).normalized();
        Vec3 right = forward.cross(up).normalized();
        Vec3 upVec = right.cross(forward).normalized();
        
        double aspectRatio = (double)width / height;
        double halfHeight = std::tan(fov * 0.5 * M_PI / 180.0);
        double halfWidth = aspectRatio * halfHeight;
        
        // Viewport在相机前方单位距离处
        Vec3 center = position + forward;
        
        Vec3 bottomLeft = center - right * halfWidth - upVec * halfHeight;
        Vec3 bottomRight = center + right * halfWidth - upVec * halfHeight;
        Vec3 topLeft = center - right * halfWidth + upVec * halfHeight;
        Vec3 topRight = center + right * halfWidth + upVec * halfHeight;
        
        // 创建两个三角形组成viewport
        Material viewportMat(MaterialType::Diffuse, Color(0, 0, 0));
        viewportTri1 = Triangle(bottomLeft, bottomRight, topRight, viewportMat);
        viewportTri2 = Triangle(bottomLeft, topRight, topLeft, viewportMat);
        
        // 设置UV坐标（用于纹理映射到最终图像）
        viewportTri1.setUV(Vec3(0, 1, 0), Vec3(1, 1, 0), Vec3(1, 0, 0));  // 注意Y轴翻转
        viewportTri2.setUV(Vec3(0, 1, 0), Vec3(1, 0, 0), Vec3(0, 0, 0));
    }
    
    void render(Scene& scene, const std::string& filename) {
        std::vector<Triangle*> triPtrs = scene.getTrianglePointers();
        int maxDepth = 4;
        
        std::cout << "Rendering viewport triangle 1..." << std::endl;
        Texture tex1 = renderTriangleWithTriangle(triPtrs, position, viewportTri1, width, height, 0, maxDepth, scene);
        
        std::cout << "Rendering viewport triangle 2..." << std::endl;
        Texture tex2 = renderTriangleWithTriangle(triPtrs, position, viewportTri2, width, height, 0, maxDepth, scene);
        
        // 合并两个三角形的纹理到最终图像
        Texture finalImage(width, height);
        
        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;
                
                // 计算在viewport平面上的3D位置
                Vec3 forward = (lookAt - position).normalized();
                Vec3 right = forward.cross(up).normalized();
                Vec3 upVec = right.cross(forward).normalized();
                
                double aspectRatio = (double)width / height;
                double halfHeight = std::tan(fov * 0.5 * M_PI / 180.0);
                double halfWidth = aspectRatio * halfHeight;
                
                Vec3 center = position + forward;
                Vec3 point = center + right * (u * 2 - 1) * halfWidth + upVec * (1 - v * 2) * halfHeight;
                
                // 检查点在哪个三角形内
                double bu, bv, bw;
                if (viewportTri1.barycentricCoords(point, bu, bv, bw) && bu >= 0 && bv >= 0 && bw >= 0) {
                    Vec3 uv = viewportTri1.getUVFromBarycentric(bu, bv, bw);
                    finalImage.setPixel(x, y, tex1.sample(uv.x, uv.y));
                } else if (viewportTri2.barycentricCoords(point, bu, bv, bw) && bu >= 0 && bv >= 0 && bw >= 0) {
                    Vec3 uv = viewportTri2.getUVFromBarycentric(bu, bv, bw);
                    finalImage.setPixel(x, y, tex2.sample(uv.x, uv.y));
                }
            }
        }
        
        // 写入PPM文件
        writePPM(filename, finalImage);
        std::cout << "Image saved to " << filename << std::endl;
    }
    
    void writePPM(const std::string& filename, const Texture& image) {
        std::ofstream file(filename);
        file << "P3\n" << image.width << " " << image.height << "\n255\n";
        
        for (int y = 0; y < image.height; ++y) {
            for (int x = 0; x < image.width; ++x) {
                Color c = image.getPixel(x, y).clamped();
                int r = (int)(c.r * 255);
                int g = (int)(c.g * 255);
                int b = (int)(c.b * 255);
                file << r << " " << g << " " << b << "\n";
            }
        }
        
        file.close();
    }
};

// ==================== 构建Cornell Box场景 ====================

void buildCornellBox(Scene& scene) {
    // Cornell Box尺寸：大约 [-1, 1] x [0, 2] x [-1, 1]
    double boxSize = 1.0;
    
    // 材质定义
    Material whiteDiffuse(MaterialType::Diffuse, Color(0.75, 0.75, 0.75));
    Material redDiffuse(MaterialType::Diffuse, Color(0.75, 0.15, 0.15));
    Material greenDiffuse(MaterialType::Diffuse, Color(0.15, 0.75, 0.15));
    Material blueReflective(MaterialType::Reflective, Color(0.2, 0.4, 0.8), 0.85);
    Material yellowReflective(MaterialType::Reflective, Color(0.8, 0.7, 0.2), 0.85);
    Material lightEmissive(MaterialType::Emissive, Color(1.0, 0.95, 0.9));
    
    // 地板（白色）
    scene.addQuad(
        Vec3(-boxSize, 0, -boxSize),
        Vec3(boxSize, 0, -boxSize),
        Vec3(boxSize, 0, boxSize),
        Vec3(-boxSize, 0, boxSize),
        whiteDiffuse
    );
    
    // 天花板（白色）
    scene.addQuad(
        Vec3(-boxSize, 2 * boxSize, boxSize),
        Vec3(boxSize, 2 * boxSize, boxSize),
        Vec3(boxSize, 2 * boxSize, -boxSize),
        Vec3(-boxSize, 2 * boxSize, -boxSize),
        whiteDiffuse
    );
    
    // 后墙（白色）
    scene.addQuad(
        Vec3(-boxSize, 0, -boxSize),
        Vec3(-boxSize, 2 * boxSize, -boxSize),
        Vec3(boxSize, 2 * boxSize, -boxSize),
        Vec3(boxSize, 0, -boxSize),
        whiteDiffuse
    );
    
    // 左墙（红色）
    scene.addQuad(
        Vec3(-boxSize, 0, boxSize),
        Vec3(-boxSize, 2 * boxSize, boxSize),
        Vec3(-boxSize, 2 * boxSize, -boxSize),
        Vec3(-boxSize, 0, -boxSize),
        redDiffuse
    );
    
    // 右墙（绿色）
    scene.addQuad(
        Vec3(boxSize, 0, -boxSize),
        Vec3(boxSize, 2 * boxSize, -boxSize),
        Vec3(boxSize, 2 * boxSize, boxSize),
        Vec3(boxSize, 0, boxSize),
        greenDiffuse
    );
    
    // 顶部灯光（发光面板）
    scene.addQuad(
        Vec3(-0.25, 1.99, -0.25),
        Vec3(0.25, 1.99, -0.25),
        Vec3(0.25, 1.99, 0.25),
        Vec3(-0.25, 1.99, 0.25),
        lightEmissive
    );
    
    // 蓝色金属盒子（左侧，稍微旋转）
    double boxHeight1 = 0.6;
    double boxWidth1 = 0.35;
    Vec3 box1Center(-0.4, boxHeight1 / 2, -0.2);
    
    // 简化：使用轴对齐的盒子
    scene.addBox(
        Vec3(box1Center.x - boxWidth1/2, 0, box1Center.z - boxWidth1/2),
        Vec3(box1Center.x + boxWidth1/2, boxHeight1, box1Center.z + boxWidth1/2),
        blueReflective
    );
    
    // 黄色金属盒子（右侧，更高一些）
    double boxHeight2 = 0.9;
    double boxWidth2 = 0.35;
    Vec3 box2Center(0.35, boxHeight2 / 2, 0.15);
    
    scene.addBox(
        Vec3(box2Center.x - boxWidth2/2, 0, box2Center.z - boxWidth2/2),
        Vec3(box2Center.x + boxWidth2/2, boxHeight2, box2Center.z + boxWidth2/2),
        yellowReflective
    );
    
    // 设置光源
    scene.lightPosition = Vec3(0, 1.95, 0);
    scene.lightColor = Color(1, 1, 1);
    scene.ambientLight = Color(0.05, 0.05, 0.05);
}

// ==================== 主函数 ====================

int main() {
    std::cout << "=== Panel-based Cornell Box Renderer ===" << std::endl;
    std::cout << "Building scene..." << std::endl;
    
    Scene scene;
    buildCornellBox(scene);
    
    std::cout << "Scene contains " << scene.triangles.size() << " triangles." << std::endl;
    
    // 设置相机
    Vec3 cameraPos(0, 1, 2.5);
    Vec3 lookAt(0, 1, 0);
    Vec3 up(0, 1, 0);
    
    int imageWidth = 400;
    int imageHeight = 400;
    double fov = 50.0;
    
    Camera camera(cameraPos, lookAt, up, fov, imageWidth, imageHeight);
    
    std::cout << "Starting render at " << imageWidth << "x" << imageHeight << "..." << std::endl;
    
    camera.render(scene, "cornell_box.ppm");
    
    std::cout << "Render complete!" << std::endl;
    
    return 0;
}