aada 0.1.1

//! 渲染负载的软件裁剪与光栅化。
//!
//! - [`Clip`]：消费 `ClipStart`/`ClipEnd` 指令做软件裁剪（Sutherland–Hodgman，嵌套取交集）。
//! - [`Render`]：把 payload 光栅化到像素/位图（重心测试 + srcOver 混合），纹理采样与像素
//!   输出通过 [`AsTexture`] / [`AsBitmap`] trait 抽象（配 `functional_trait` 可直接传闭包）。

use functional_trait::functional_trait;
use glam::{Affine2, Vec2};

use crate::data::runtime::mesh::MeshIdx;
use crate::data::runtime::payload::{MeshPayload, PayloadUsage};

/// 软件裁剪：把渲染负载列表中的 [PayloadUsage::ClipStart] / [PayloadUsage::ClipEnd]
/// 指令消费掉，将其间出现的普通网格裁剪到裁剪多边形区域内
///
/// 裁剪后：
/// - [PayloadUsage::Mesh] 的 positions / uvs / indices 被替换为裁剪后的数据
/// - 完全被裁剪掉的网格从列表中移除
/// - ClipStart / ClipEnd 指令保留原样（渲染层仍可自行选择 GPU stencil 等方案）
///
/// 嵌套裁剪取交集：裁剪网格的同时，栈顶裁剪多边形更新为裁剪结果
/// 纹理采样接口：给定 UV 坐标返回 RGBA（各分量 0-1）
///
/// 由使用方实现（如从 bevy 图像、图集页、程序生成纹理采样），
/// 供 [Render::render_pixel] / [Render::render_bitmap] 光栅化时应用纹理
///（functional_trait 宏：任何 `Fn(u32, u32) -> [f32; 4]` 闭包可直接作为采样器，
/// 无需定义 struct + impl）
#[functional_trait]
pub trait AsTexture {
    fn uv(&self, u: f32, v: f32) -> [f32; 4];
}

/// 位图输出目标：渲染结果逐个像素写入
///
/// 由使用方实现（内存位图、PNG 编码器、调试视图等）
///（functional_trait 宏：`FnMut(u32, u32, [f32; 4])` 闭包可直接作为输出目标）
#[functional_trait]
pub trait AsBitmap {
    /// 设置位图 (x, y) 处像素颜色（RGBA 各分量 0-1）
    fn set_pixel(&mut self, x: usize, y: usize, rgba: [f32; 4]);
}

/// 软件裁剪：把渲染负载列表中的 [PayloadUsage::ClipStart] / [PayloadUsage::ClipEnd]
/// 指令消费掉，将其间出现的普通网格裁剪到裁剪多边形区域内
///
/// 裁剪后：
/// - [PayloadUsage::Mesh] 的 positions / uvs / indices 被替换为裁剪后的数据
/// - 完全被裁剪掉的网格从列表中移除
/// - ClipStart / ClipEnd 指令保留原样（渲染层仍可自行选择 GPU stencil 等方案）
///
/// 嵌套裁剪取交集：裁剪网格的同时，栈顶裁剪多边形更新为裁剪结果
pub trait Clip {
    /// 执行软件裁剪（原地修改）
    fn clip_software(&mut self);
}

/// 软件合并：把多个网格合并成更少的网格（减少渲染 draw call / 每帧上传次数）
///
/// 应在 [`Clip::clip_software`] 之后调用（裁剪指令已消费、网格已裁剪）。
/// 合并时把每个网格的 `uv_transform` **应用进它的 uvs**（结果统一为 identity），
/// 因此不同 uv_transform 的网格也能合并；只有 `tint_color` 不同的网格才分成独立组
/// （tint 无法"应用掉"，合并后每网格的颜色必须保持）。
///
/// - `separate_at_clip = false`：忽略裁剪指令，所有网格按 tint 合并成尽可能少的组
/// - `separate_at_clip = true`：在 ClipStart/ClipEnd 周围分隔——裁剪区域内的网格与区域外的网格
///   分属不同组（嵌套裁剪各占一层），便于渲染层对裁剪区域单独处理
///
/// 合并后 ClipStart / ClipEnd 指令被消费（软件裁剪已完成，指令不再需要），
/// 组内 `slot` / `MeshIdx` 取该组第一个网格的，`uv_transform` 恒为 identity。
pub trait Merge {
    /// 软件合并所有网格（原地修改，合并结果替换原列表）
    fn merge_meshes(&mut self, separate_at_clip: bool);
}

impl Merge for Vec<MeshPayload> {
    fn merge_meshes(&mut self, separate_at_clip: bool) {
        struct Group {
            depth: usize,
            positions: Vec<Vec2>,
            uvs: Vec<Vec2>,
            indices: Vec<u32>,
            tint: [f32; 4],
            slot: crate::data::runtime::slot::SlotIdx,
            mesh_idx: MeshIdx,
        }
        let mut depth = 0usize;
        let mut groups: Vec<Group> = Vec::new();
        for payload in std::mem::take(self) {
            match payload.usage {
                PayloadUsage::ClipStart { .. } => {
                    if separate_at_clip {
                        depth += 1;
                    }
                }
                PayloadUsage::ClipEnd { .. } => {
                    if separate_at_clip {
                        depth = depth.saturating_sub(1);
                    }
                }
                PayloadUsage::Mesh(mesh_idx) => {
                    let d = if separate_at_clip { depth } else { 0 };
                    // 把 uv_transform 应用进 uvs（合并后统一 identity，不同变换的网格也能合并）
                    let uv_transform = payload.uv_transform;
                    let uvs: Vec<Vec2> = payload
                        .uvs
                        .iter()
                        .map(|&uv| uv_transform.transform_point2(uv))
                        .collect();
                    let mut gi = None;
                    for (i, g) in groups.iter().enumerate() {
                        if g.depth == d && g.tint == payload.tint_color {
                            gi = Some(i);
                            break;
                        }
                    }
                    let gi = match gi {
                        Some(i) => i,
                        None => {
                            groups.push(Group {
                                depth: d,
                                positions: Vec::new(),
                                uvs: Vec::new(),
                                indices: Vec::new(),
                                tint: payload.tint_color,
                                slot: payload.slot,
                                mesh_idx,
                            });
                            groups.len() - 1
                        }
                    };
                    let g = &mut groups[gi];
                    let base = g.positions.len() as u32;
                    g.positions.extend(payload.positions);
                    g.uvs.extend(uvs);
                    g.indices.extend(payload.indices.iter().map(|&i| i + base));
                }
            }
        }
        *self = groups
            .into_iter()
            .map(|g| {
                MeshPayload::new(
                    PayloadUsage::Mesh(g.mesh_idx),
                    g.slot,
                    g.positions,
                    g.uvs,
                    g.indices,
                    g.tint,
                    Affine2::IDENTITY,
                )
            })
            .collect();
    }
}

/// 光栅化：把 [MeshPayload] 列表渲染成像素（逐像素查询 / 整体位图 / 包围盒）
pub trait Render {
    /// 渲染单个像素：直接对模型空间坐标 (x, y) 做重心测试，从后往前（渲染顺序靠后的在上）
    /// 以 srcOver 叠加所有命中三角形，返回 RGBA（各分量 0-1）。
    ///
    /// 传入 [AsTexture] 则应用纹理；None 时直接用 tint。
    /// 未命中（无三角形覆盖）返回透明黑 [0, 0, 0, 0]。
    ///
    /// `premultiplied_alpha=true` 表示纹理为预乘 alpha 编码（rgb 已乘过 alpha，
    /// 如 spine atlas 的 `pma: true`）：内部改用预乘 srcOver 混合避免暗边，
    /// 输出颜色与默认（直通纹理）渲染同一内容时完全一致。
    ///
    /// 泛型 T：闭包/struct 均可直接传（?Sized 允许 `&dyn AsTexture`），单态化无虚调用。
    fn render_pixel<T: AsTexture + ?Sized>(
        &self,
        x: f32,
        y: f32,
        tex: Option<&T>,
        premultiplied_alpha: bool,
    ) -> [f32; 4];

    /// 整个网格的轴对齐包围盒：遍历所有普通网格（[PayloadUsage::Mesh]）顶点，
    /// 返回 (min, max) 模型空间坐标；没有网格时返回 None。
    fn aabb(&self) -> Option<(Vec2, Vec2)>;

    /// 渲染位图：按渲染顺序（靠后覆盖靠前）把 payload 光栅化到 width×height 位图。
    ///
    /// 每个三角形取包围盒（裁剪到位图范围）后扫描其中的像素，做重心测试；
    /// 命中像素以 srcOver 混合写入"纹理采样 × tint"颜色（传 None 则纯 tint）——
    /// 半透明的后画像素正确叠加，不会把下面网格挖出空洞。
    /// 坐标映射（先位移后缩放：offset 为视口中心在模型空间的坐标，half_extent 为每轴半范围，
    /// 允许不等长宽缩放）：
    ///   col = ((x - offset.x) / half_extent.x + 1.0) * 0.5 * width
    ///   row = height-1 - ((y - offset.y) / half_extent.y + 1.0) * 0.5 * height
    /// 即 ±half_extent（相对 offset）对应位图 [0,width)×[0,height)，y 向上翻转。
    /// 例如 `half_extent = Vec2::new(400.0, 200.0)` 表示以 offset 为中心、模型空间里
    /// 800×400 的矩形区域会被拉伸到整张 W×H 位图。
    /// 背景（未被任何三角形覆盖）像素不调用 [AsBitmap::set_pixel]（由使用方决定底色）。
    ///
    /// `premultiplied_alpha=true` 表示纹理为预乘 alpha 编码（rgb 已乘过 alpha，
    /// 如 spine atlas 的 `pma: true`）：内部改用预乘 srcOver 混合避免暗边，
    /// 写出的颜色与默认（直通纹理）渲染同一内容时完全一致。
    ///
    /// 泛型 T/B：闭包/struct 均可直接传（?Sized 允许 `&dyn` trait object），单态化无虚调用。
    fn render_bitmap<T: AsTexture + ?Sized, B: AsBitmap + ?Sized>(
        &self,
        width: usize,
        height: usize,
        half_extent: Vec2,
        offset: Vec2,
        tex: Option<&T>,
        premultiplied_alpha: bool,
        out: &mut B,
    );

    /// 渲染剪影位图：不采样纹理，以 tint 纯色填充（等价于 [`Render::render_bitmap`] 传 `None` 纹理）。
    ///
    /// 坐标映射与混合规则与 [`Render::render_bitmap`] 完全一致，适合输出角色剪影 /
    /// 无纹理预览 / 阴影图。
    fn render_tint<B: AsBitmap + ?Sized>(
        &self,
        width: usize,
        height: usize,
        half_extent: Vec2,
        offset: Vec2,
        out: &mut B,
    ) {
        self.render_bitmap(width, height, half_extent, offset, None::<&dyn AsTexture>, false, out)
    }
}

/// 一次裁剪操作的输出：网格数据（positions / uvs / indices 已裁剪）
struct ClipResult {
    positions: Vec<Vec2>,
    uvs: Vec<Vec2>,
    indices: Vec<u32>,
}

impl Clip for Vec<MeshPayload> {
    fn clip_software(&mut self) {
        // 裁剪栈：多边形为闭合顶点列表（不重复首尾），逆时针方向
        let mut clip_stack: Vec<Vec<Vec2>> = Vec::new();
        let mut out: Vec<MeshPayload> = Vec::with_capacity(self.len());
        for mut payload in std::mem::take(self) {
            match payload.usage {
                PayloadUsage::ClipStart { .. } => {
                    // 变形后的多边形顶点即裁剪区域（规范化方向：Sutherland–Hodgman 要求逆时针）
                    let poly = normalize_polygon(std::mem::take(&mut payload.positions));
                    // 嵌套：新裁剪区域与已有裁剪区域取交集
                    let poly = match clip_stack.last() {
                        Some(top) => clip_polygon(&poly, top).unwrap_or_default(),
                        None => poly,
                    };
                    if !poly.is_empty() {
                        clip_stack.push(poly);
                    }
                }
                PayloadUsage::ClipEnd { .. } => {
                    clip_stack.pop();
                }
                PayloadUsage::Mesh(_) => {
                    if !clip_stack.is_empty() {
                        let mut positions = std::mem::take(&mut payload.positions);
                        let mut uvs = std::mem::take(&mut payload.uvs);
                        let mut indices = std::mem::take(&mut payload.indices);
                        // 依次被栈内所有裁剪区域裁剪（嵌套取交集）
                        let mut fully_cut = false;
                        for poly in &clip_stack {
                            match clip_mesh(&positions, &uvs, &indices, poly) {
                                Some(result) => {
                                    positions = result.positions;
                                    uvs = result.uvs;
                                    indices = result.indices;
                                }
                                None => {
                                    fully_cut = true;
                                    break;
                                }
                            }
                        }
                        if fully_cut {
                            // 完全被裁掉：从列表中移除
                            continue;
                        }
                        payload.positions = positions;
                        payload.uvs = uvs;
                        payload.indices = indices;
                    }
                }
            }
            out.push(payload);
        }
        *self = out;
    }
}

/// 组合"纹理采样 × tint"得到源色。
///
/// `premultiplied_alpha=true` 时纹理为预乘编码（rgb 已乘过 alpha），tint 为直通
/// （其 alpha 也要预乘进结果 rgb），输出预乘形式的 rgb 供预乘 srcOver 使用。
#[inline]
fn blend_src(tc: [f32; 4], tint: [f32; 4], premultiplied_alpha: bool) -> [f32; 4] {
    if premultiplied_alpha {
        [
            tc[0] * tint[0] * tint[3],
            tc[1] * tint[1] * tint[3],
            tc[2] * tint[2] * tint[3],
            tc[3] * tint[3],
        ]
    } else {
        [
            tc[0] * tint[0],
            tc[1] * tint[1],
            tc[2] * tint[2],
            tc[3] * tint[3],
        ]
    }
}

/// srcOver 混合：把 src 叠到 dst 上。
///
/// `premultiplied_alpha=true` 时用预乘公式 `out = src + dst × (1 - src.a)`
/// （src 必须已预乘）；否则用直通公式 `out = src × a + dst × (1 - a)`。
#[inline]
fn src_over(dst: &mut [f32; 4], src: [f32; 4], premultiplied_alpha: bool) {
    if src[3] >= 1.0 {
        *dst = src;
    } else if premultiplied_alpha {
        let ia = 1.0 - src[3];
        dst[0] = src[0] + dst[0] * ia;
        dst[1] = src[1] + dst[1] * ia;
        dst[2] = src[2] + dst[2] * ia;
        dst[3] = src[3] + dst[3] * ia;
    } else {
        let a = src[3];
        let ia = 1.0 - a;
        dst[0] = src[0] * a + dst[0] * ia;
        dst[1] = src[1] * a + dst[1] * ia;
        dst[2] = src[2] * a + dst[2] * ia;
        dst[3] = a + dst[3] * ia;
    }
}

impl Render for Vec<MeshPayload> {
    fn render_pixel<T: AsTexture + ?Sized>(
        &self,
        x: f32,
        y: f32,
        tex: Option<&T>,
        premultiplied_alpha: bool,
    ) -> [f32; 4] {
        // 边缘容差：避免共享边/顶点处浮点误差导致漏判
        const EPS: f32 = 1e-4;
        // 从后往前（渲染顺序靠后的在上），srcOver 叠加所有命中三角形：
        // 与 GPU Blend 一致，避免后画的透明像素把下面的颜色挖掉
        let mut acc = [0.0f32; 4];
        for payload in self.iter().rev() {
            let PayloadUsage::Mesh(_) = payload.usage else {
                continue;
            };
            let tint = payload.tint_color;
            for tri in payload.indices.chunks_exact(3) {
                let p0 = payload.positions[tri[0] as usize];
                let p1 = payload.positions[tri[1] as usize];
                let p2 = payload.positions[tri[2] as usize];
                // 重心坐标测试
                let v0 = p1 - p0;
                let v1 = p2 - p0;
                let v2 = Vec2::new(x, y) - p0;
                let denom = v0.x * v1.y - v1.x * v0.y;
                if denom.abs() <= 1e-9 {
                    continue;
                }
                let inv = 1.0 / denom;
                let u = (v2.x * v1.y - v1.x * v2.y) * inv;
                let v = (v0.x * v2.y - v2.x * v0.y) * inv;
                if u < -EPS || v < -EPS || u + v > 1.0 + EPS {
                    continue;
                }
                // 命中：插值 UV -> 纹理采样 × tint
                let uv0 = payload.uvs[tri[0] as usize];
                let uv1 = payload.uvs[tri[1] as usize];
                let uv2 = payload.uvs[tri[2] as usize];
                let uv = uv0 + (uv1 - uv0) * u + (uv2 - uv0) * v;
                let tc = match tex {
                    Some(t) => t.uv(uv.x, uv.y),
                    None => [1.0, 1.0, 1.0, 1.0],
                };
                let src = blend_src(tc, tint, premultiplied_alpha);
                // 倒序统一用预乘 srcOver（与 render_bitmap 缓冲语义一致）：
                // acc 是已处理的"上层"预乘色，把 acc 叠到当前"下层"（转成预乘形式）上
                let (sr, sg, sb, sa) = (src[0], src[1], src[2], src[3]);
                let mut pm = if premultiplied_alpha {
                    src
                } else {
                    [sr * sa, sg * sa, sb * sa, sa]
                };
                src_over(&mut pm, acc, true);
                acc = pm;
                // 同一 mesh 内三角形不重叠（仅共享边/顶点可能重复命中），只处理一次
                break;
            }
            if acc[3] >= 1.0 {
                break; // 已不透明，下面的不再可见
            }
        }
        acc
    }

    fn aabb(&self) -> Option<(Vec2, Vec2)> {
        let mut min = Vec2::splat(f32::INFINITY);
        let mut max = Vec2::splat(f32::NEG_INFINITY);
        let mut found = false;
        for payload in self {
            let PayloadUsage::Mesh(_) = payload.usage else {
                continue;
            };
            for &p in &payload.positions {
                min = min.min(p);
                max = max.max(p);
                found = true;
            }
        }
        found.then_some((min, max))
    }

    fn render_bitmap<T: AsTexture + ?Sized, B: AsBitmap + ?Sized>(
        &self,
        width: usize,
        height: usize,
        half_extent: Vec2,
        offset: Vec2,
        tex: Option<&T>,
        premultiplied_alpha: bool,
        out: &mut B,
    ) {
        if width == 0 || height == 0 {
            return;
        }
        // 混合缓冲：按渲染顺序 srcOver 累加（后画的半透明像素正确叠在前面的颜色上，
        // 与 GPU Blend 一致；否则后画的透明像素会把下面的网格挖出空洞）
        let mut buf = vec![[0.0f32; 4]; width * height];
        let to_col =
            |v: f32| { ((v - offset.x) / half_extent.x + 1.0) * 0.5 * width as f32 } as isize;
        let to_row = |v: f32| {
            height as isize
                - 1
                - (((v - offset.y) / half_extent.y + 1.0) * 0.5 * height as f32) as isize
        };

        for payload in self {
            let PayloadUsage::Mesh(_) = payload.usage else {
                continue;
            };
            let tint = payload.tint_color;
            for tri in payload.indices.chunks_exact(3) {
                let p0 = payload.positions[tri[0] as usize];
                let p1 = payload.positions[tri[1] as usize];
                let p2 = payload.positions[tri[2] as usize];
                let uv0 = payload.uvs[tri[0] as usize];
                let uv1 = payload.uvs[tri[1] as usize];
                let uv2 = payload.uvs[tri[2] as usize];
                // 三角形包围盒（位图空间），裁剪到位图范围
                let min_x = p0.x.min(p1.x).min(p2.x);
                let max_x = p0.x.max(p1.x).max(p2.x);
                let min_y = p0.y.min(p1.y).min(p2.y);
                let max_y = p0.y.max(p1.y).max(p2.y);
                let c0 = to_col(min_x).max(0).min(width as isize - 1);
                let c1 = (to_col(max_x) + 1).clamp(0, width as isize);
                let r0 = to_row(max_y).max(0).min(height as isize - 1);
                let r1 = (to_row(min_y) + 1).clamp(0, height as isize);
                if c0 >= c1 || r0 >= r1 {
                    continue;
                }
                let v0 = p1 - p0;
                let v1 = p2 - p0;
                let denom = v0.x * v1.y - v1.x * v0.y;
                if denom.abs() <= 1e-9 {
                    continue;
                }
                let inv = 1.0 / denom;
                for row in r0..r1 {
                    for col in c0..c1 {
                        // 像素中心 -> 模型空间坐标（位图空间先归一化到 ±half_extent，再加视口中心 offset）
                        let sx = (col as f32 + 0.5) / width as f32 * 2.0 * half_extent.x
                            - half_extent.x
                            + offset.x;
                        let sy =
                            (height as f32 - 0.5 - row as f32) / height as f32 * 2.0 * half_extent.y
                                - half_extent.y
                                + offset.y;
                        // 重心坐标测试
                        let v2 = Vec2::new(sx, sy) - p0;
                        let u = (v2.x * v1.y - v1.x * v2.y) * inv;
                        let v = (v0.x * v2.y - v2.x * v0.y) * inv;
                        if u < 0.0 || v < 0.0 || u + v > 1.0 {
                            continue;
                        }
                        // 插值 UV -> 纹理采样 × tint
                        let uv = uv0 + (uv1 - uv0) * u + (uv2 - uv0) * v;
                        let tc = match tex {
                            Some(t) => t.uv(uv.x, uv.y),
                            None => [1.0, 1.0, 1.0, 1.0],
                        };
                        let src = blend_src(tc, tint, premultiplied_alpha);
                        // srcOver 混合到缓冲（a>=1 直接覆盖）
                        let dst = &mut buf[row as usize * width + col as usize];
                        src_over(dst, src, premultiplied_alpha);
                    }
                }
            }
        }
        // 写出缓冲：仅写被覆盖过的像素（背景保持由使用方决定底色）
        for (i, pixel) in buf.iter().enumerate() {
            if pixel[3] > 0.0 {
                out.set_pixel(i % width, i / width, *pixel);
            }
        }
    }
}

/// 用裁剪多边形裁剪一个网格（Sutherland–Hodgman 逐三角形裁剪 + fan 三角形化）
///
/// `clip_polygon` 为闭合多边形顶点（首尾不重复），逆时针方向。
/// 返回 None 表示网格被完全裁剪掉。
fn clip_mesh(
    positions: &[Vec2],
    uvs: &[Vec2],
    indices: &[u32],
    clip_polygon: &[Vec2],
) -> Option<ClipResult> {
    debug_assert!(clip_polygon.len() >= 3);
    if clip_polygon.len() < 3 || positions.is_empty() {
        return None;
    }

    // 三角形顶点池：每个三角形独立输出，交点顶点追加在末尾
    let mut out_positions: Vec<Vec2> = Vec::new();
    let mut out_uvs: Vec<Vec2> = Vec::new();
    let mut out_indices: Vec<u32> = Vec::new();

    // 当前裁剪多边形的边界边（固定，不随裁剪变化）
    let edges: Vec<(Vec2, Vec2)> = clip_polygon
        .iter()
        .zip(
            clip_polygon
                .iter()
                .skip(1)
                .chain(clip_polygon.iter().take(1)),
        )
        .map(|(&a, &b)| (a, b))
        .collect();
    // 双缓冲：三角形 vs 多边形逐边裁剪交替读写，预分配避免每三角形/每边分配
    // 每条边最多新增 1 个交点，起始 3 顶点
    let mut cur: Vec<(Vec2, Vec2)> = Vec::with_capacity(3 + edges.len());
    let mut next: Vec<(Vec2, Vec2)> = Vec::with_capacity(3 + edges.len());

    for tri in indices.chunks_exact(3) {
        let [i0, i1, i2] = [tri[0], tri[1], tri[2]];
        if (i0 as usize) >= positions.len()
            || (i1 as usize) >= positions.len()
            || (i2 as usize) >= positions.len()
        {
            continue;
        }

        // 当前裁剪多边形的顶点列表（位置 + UV），初始为三角形三个顶点
        cur.clear();
        cur.push((positions[i0 as usize], uvs[i0 as usize]));
        cur.push((positions[i1 as usize], uvs[i1 as usize]));
        cur.push((positions[i2 as usize], uvs[i2 as usize]));

        // 逐条 clip 边裁剪（Sutherland–Hodgman）
        let mut clipped = false;
        for &(a, b) in &edges {
            next.clear();
            let n = cur.len();
            for k in 0..n {
                let curr = cur[k];
                let nxt = cur[(k + 1) % n];
                let inside_curr = inside(curr.0, a, b);
                let inside_next = inside(nxt.0, a, b);
                match (inside_curr, inside_next) {
                    (true, true) => next.push(nxt),
                    (true, false) => {
                        if let Some(p) = intersect(curr, nxt, a, b) {
                            next.push(p);
                        }
                    }
                    (false, true) => {
                        if let Some(p) = intersect(curr, nxt, a, b) {
                            next.push(p);
                        }
                        next.push(nxt);
                    }
                    (false, false) => {}
                }
            }
            std::mem::swap(&mut cur, &mut next);
            if cur.len() < 3 {
                clipped = true;
                break;
            }
        }

        if clipped || cur.len() < 3 {
            continue;
        }

        // fan 三角形化：多边形顶点直接进输出池（交点已插值 UV）
        let base = out_positions.len() as u32;
        for &(p, u) in &cur {
            out_positions.push(p);
            out_uvs.push(u);
        }
        for k in 1..cur.len() - 1 {
            out_indices.push(base);
            out_indices.push(base + k as u32);
            out_indices.push(base + k as u32 + 1);
        }
    }

    if out_indices.is_empty() {
        return None;
    }
    Some(ClipResult {
        positions: out_positions,
        uvs: out_uvs,
        indices: out_indices,
    })
}

/// 多边形 vs 多边形裁剪（Sutherland–Hodgman）：用 `clip` 裁剪闭合多边形 `poly`
///
/// 返回交集多边形（逆时针）；交集为空时返回 None
fn clip_polygon(poly: &[Vec2], clip: &[Vec2]) -> Option<Vec<Vec2>> {
    // 双缓冲：逐边裁剪交替读写，预分配避免每边分配（每条边最多新增 1 个交点）
    let mut cur: Vec<Vec2> = Vec::with_capacity(poly.len() + clip.len());
    cur.extend_from_slice(poly);
    let mut next: Vec<Vec2> = Vec::with_capacity(poly.len() + clip.len());
    for i in 0..clip.len() {
        let a = clip[i];
        let b = clip[(i + 1) % clip.len()];
        next.clear();
        let n = cur.len();
        for k in 0..n {
            let c = cur[k];
            let d = cur[(k + 1) % n];
            let inside_c = inside(c, a, b);
            let inside_d = inside(d, a, b);
            match (inside_c, inside_d) {
                (true, true) => next.push(d),
                (true, false) => {
                    if let Some(p) = intersect_pos(c, d, a, b) {
                        next.push(p);
                    }
                }
                (false, true) => {
                    if let Some(p) = intersect_pos(c, d, a, b) {
                        next.push(p);
                    }
                    next.push(d);
                }
                (false, false) => {}
            }
        }
        std::mem::swap(&mut cur, &mut next);
        if cur.len() < 3 {
            return None;
        }
    }
    Some(cur)
}

/// 点 p 是否在边 (a -> b) 内侧（逆时针多边形的内侧为左侧）
#[inline]
fn inside(p: Vec2, a: Vec2, b: Vec2) -> bool {
    (b - a).perp_dot(p - a) >= 0.0
}

/// 规范化多边形方向为逆时针（有向面积为正；负面积则反转顶点顺序）
///
/// 与 spine 参考实现（spine-c 的 `_makeClockwise`）语义一致：
/// 不同导出器产生的裁剪多边形方向不保证一致，Sutherland–Hodgman 要求与 inside 判定一致
fn normalize_polygon(mut poly: Vec<Vec2>) -> Vec<Vec2> {
    if poly.len() < 3 {
        return poly;
    }
    let mut area2 = 0.0;
    for i in 0..poly.len() {
        let a = poly[i];
        let b = poly[(i + 1) % poly.len()];
        area2 += a.x * b.y - b.x * a.y;
    }
    if area2 < 0.0 {
        poly.reverse();
    }
    poly
}

/// 线段 curr -> next 与裁剪边 a -> b 的交点（位置 + UV 线性插值）
#[inline]
fn intersect(curr: (Vec2, Vec2), next: (Vec2, Vec2), a: Vec2, b: Vec2) -> Option<(Vec2, Vec2)> {
    let p = intersect_pos(curr.0, next.0, a, b)?;
    let e2 = next.0 - curr.0;
    let t = if e2.length_squared() > 1e-12 {
        ((p - curr.0).dot(e2) / e2.length_squared()).clamp(0.0, 1.0)
    } else {
        0.0
    };
    let u = curr.1 + (next.1 - curr.1) * t;
    Some((p, u))
}

/// 线段 c -> d 与裁剪边 a -> b 的交点（仅位置）
#[inline]
fn intersect_pos(c: Vec2, d: Vec2, a: Vec2, b: Vec2) -> Option<Vec2> {
    let e1 = b - a;
    let e2 = d - c;
    let denom = e2.perp_dot(e1);
    if denom.abs() < 1e-9 {
        // 平行：无有效交点（不应出现在严格的内外过渡中）
        return None;
    }
    let t = (a - c).perp_dot(e1) / denom;
    let t = t.clamp(0.0, 1.0);
    Some(c + e2 * t)
}

#[cfg(test)]
mod tests {
    use super::*;

    fn square_payload(min: Vec2, max: Vec2) -> MeshPayload {
        let positions = vec![
            Vec2::new(min.x, min.y),
            Vec2::new(max.x, min.y),
            Vec2::new(max.x, max.y),
            Vec2::new(min.x, max.y),
        ];
        let uvs = vec![
            Vec2::new(0.0, 0.0),
            Vec2::new(1.0, 0.0),
            Vec2::new(1.0, 1.0),
            Vec2::new(0.0, 1.0),
        ];
        MeshPayload::new(
            PayloadUsage::Mesh(unsafe { crate::custom_index::AsIndex::from_index(0) }),
            unsafe { crate::custom_index::AsIndex::from_index(0) },
            positions,
            uvs,
            vec![0, 1, 2, 0, 2, 3],
            [1.0; 4],
            glam::Affine2::IDENTITY,
        )
    }

    #[test]
    fn clip_software_cuts_mesh_to_polygon() {
        // clip 区域：单位正方形 (0,0)-(1,1)
        let clip_polygon = vec![
            Vec2::new(0.0, 0.0),
            Vec2::new(1.0, 0.0),
            Vec2::new(1.0, 1.0),
            Vec2::new(0.0, 1.0),
        ];
        let mut payloads = vec![
            MeshPayload::new(
                PayloadUsage::ClipStart {
                    id: unsafe { crate::custom_index::AsIndex::from_index(0) },
                },
                unsafe { crate::custom_index::AsIndex::from_index(0) },
                clip_polygon,
                Vec::new(),
                Vec::new(),
                [1.0; 4],
                glam::Affine2::IDENTITY,
            ),
            // 大正方形 (-0.5,-0.5)-(1.5,1.5)：超出 clip 区域，应被裁剪
            square_payload(Vec2::new(-0.5, -0.5), Vec2::new(1.5, 1.5)),
            MeshPayload::new(
                PayloadUsage::ClipEnd {
                    id: unsafe { crate::custom_index::AsIndex::from_index(0) },
                },
                unsafe { crate::custom_index::AsIndex::from_index(0) },
                Vec::new(),
                Vec::new(),
                Vec::new(),
                [1.0; 4],
                glam::Affine2::IDENTITY,
            ),
        ];
        payloads.clip_software();

        // 指令保留
        assert!(matches!(payloads[0].usage, PayloadUsage::ClipStart { .. }));
        assert!(matches!(payloads[2].usage, PayloadUsage::ClipEnd { .. }));
        // mesh 被裁剪：顶点全部落在 clip 区域内
        let mesh = &payloads[1];
        assert_eq!(mesh.positions.len(), mesh.uvs.len());
        assert!(mesh.indices.len() >= 6);
        for p in &mesh.positions {
            assert!(p.x >= -1e-5 && p.x <= 1.0 + 1e-5, "x={p}");
            assert!(p.y >= -1e-5 && p.y <= 1.0 + 1e-5, "y={p}");
        }
        // 裁剪后三角形顶点数多于原始 4 顶点（被切碎）
        assert!(
            mesh.positions.len() > 4,
            "裁剪后应产生新顶点: {}",
            mesh.positions.len()
        );
    }

    #[test]
    fn clip_software_removes_fully_cut_mesh() {
        // clip 区域：单位正方形 (0,0)-(1,1)
        let clip_polygon = vec![
            Vec2::new(0.0, 0.0),
            Vec2::new(1.0, 0.0),
            Vec2::new(1.0, 1.0),
            Vec2::new(0.0, 1.0),
        ];
        let mut payloads = vec![
            MeshPayload::new(
                PayloadUsage::ClipStart {
                    id: unsafe { crate::custom_index::AsIndex::from_index(0) },
                },
                unsafe { crate::custom_index::AsIndex::from_index(0) },
                clip_polygon,
                Vec::new(),
                Vec::new(),
                [1.0; 4],
                glam::Affine2::IDENTITY,
            ),
            // 完全在 clip 区域外：应被移除
            square_payload(Vec2::new(2.0, 2.0), Vec2::new(3.0, 3.0)),
            MeshPayload::new(
                PayloadUsage::ClipEnd {
                    id: unsafe { crate::custom_index::AsIndex::from_index(0) },
                },
                unsafe { crate::custom_index::AsIndex::from_index(0) },
                Vec::new(),
                Vec::new(),
                Vec::new(),
                [1.0; 4],
                glam::Affine2::IDENTITY,
            ),
        ];
        payloads.clip_software();
        assert_eq!(payloads.len(), 2, "完全被裁掉的网格应移除");
    }

    /// 回归：真实 Aya 数据（Eye_R_Clip 多边形 + Eyebody_Idle_R 网格，重叠区域明显）
    #[test]
    fn clip_aya_real_data_overlaps() {
        // 顺时针原始数据（clip_software 会规范化）
        let clip_polygon = vec![
            Vec2::new(-89.20994, 555.9128),
            Vec2::new(-66.166855, 560.08997),
            Vec2::new(-44.71911, 560.0063),
            Vec2::new(-25.425596, 557.4294),
            Vec2::new(-11.843452, 552.75586),
            Vec2::new(-21.501608, 545.0098),
            Vec2::new(-35.769283, 541.7343),
            Vec2::new(-53.30312, 539.16125),
            Vec2::new(-72.196556, 537.8067),
            Vec2::new(-95.73134, 542.27637),
        ];
        let mesh_positions = vec![
            Vec2::new(-52.31537, 580.1522),
            Vec2::new(-32.943085, 569.6864),
            Vec2::new(-21.479704, 544.66406),
            Vec2::new(-21.48632, 528.79535),
            Vec2::new(-40.4547, 525.3975),
            Vec2::new(-55.146145, 528.87854),
            Vec2::new(-69.72027, 525.9573),
            Vec2::new(-80.33296, 536.7864),
            Vec2::new(-86.4835, 546.76855),
            Vec2::new(-70.21397, 581.0802),
        ];
        let mesh_uvs: Vec<Vec2> = (0..mesh_positions.len())
            .map(|i| Vec2::splat(i as f32))
            .collect();
        let indices: Vec<u32> = vec![
            0, 1, 2, 0, 2, 3, 0, 3, 4, 0, 4, 5, 0, 5, 6, 0, 6, 7, 0, 7, 8, 0, 8, 9, 0, 9, 1,
        ];
        // 规范化方向后的裁剪
        let poly = normalize_polygon(clip_polygon.clone());
        let area2 = {
            let mut a = 0.0;
            for i in 0..poly.len() {
                let p = poly[i];
                let q = poly[(i + 1) % poly.len()];
                a += p.x * q.y - q.x * p.y;
            }
            a
        };
        assert!(area2 > 0.0, "规范化后应逆时针: {area2}");
        let result = clip_mesh(&mesh_positions, &mesh_uvs, &indices, &poly);
        assert!(result.is_some(), "重叠明显的网格不应被完全裁掉");
        if let Some(r) = result {
            eprintln!(
                "aya clip: {} verts {} tris (in poly {})",
                r.positions.len(),
                r.indices.len(),
                poly.len()
            );
            assert!(!r.indices.is_empty());
        }
    }

    #[test]
    fn render_pixel_samples_rendered_triangle() {
        // 大正方形覆盖中心区域（位图 256² 覆盖 ±1024，每像素 8 单位，三角形需明显大于像素）
        let mut payloads = vec![square_payload(
            Vec2::new(-200.0, -200.0),
            Vec2::new(200.0, 200.0),
        )];
        payloads[0].tint_color = [1.0, 0.0, 0.0, 1.0];
        // 中心点命中 -> 红色
        let c = payloads.render_pixel(0.0, 0.0, None::<&dyn AsTexture>, false);
        assert!(
            c[0] > 0.9 && c[1] < 0.1 && c[2] < 0.1 && c[3] > 0.9,
            "{c:?}"
        );
        // 远处未命中 -> 透明
        let c = payloads.render_pixel(500.0, 500.0, None::<&dyn AsTexture>, false);
        assert_eq!(c, [0.0, 0.0, 0.0, 0.0], "{c:?}");
        // 靠后 payload 覆盖靠前
        let mut red = square_payload(Vec2::new(-200.0, -200.0), Vec2::new(200.0, 200.0));
        red.tint_color = [1.0, 0.0, 0.0, 1.0];
        let mut blue = square_payload(Vec2::new(-50.0, -50.0), Vec2::new(50.0, 50.0));
        blue.tint_color = [0.0, 0.0, 1.0, 1.0];
        let payloads = vec![red, blue];
        let c = payloads.render_pixel(0.0, 0.0, None::<&dyn AsTexture>, false);
        assert!(c[2] > 0.9 && c[0] < 0.1, "{c:?}");
        let c = payloads.render_pixel(150.0, 150.0, None::<&dyn AsTexture>, false);
        assert!(c[0] > 0.9 && c[2] < 0.1, "{c:?}");
    }

    #[test]
    fn render_pixel_applies_texture_uv() {
        // 纯色纹理：左边红、右边绿（functional_trait 闭包直接实现 AsTexture）
        let tex: &dyn AsTexture = &|u: f32, _v: f32| -> [f32; 4] {
            if u < 0.5 {
                [1.0, 0.0, 0.0, 1.0]
            } else {
                [0.0, 1.0, 0.0, 1.0]
            }
        };
        // 正方形 (0,0)-(100,100)，UV 与模型坐标 1:1
        let mut payloads = vec![square_payload(Vec2::new(0.0, 0.0), Vec2::new(100.0, 100.0))];
        payloads[0].tint_color = [1.0; 4];
        // 左半 -> 红，右半 -> 绿
        let c = payloads.render_pixel(25.0, 50.0, Some(tex), false);
        assert!(c[0] > 0.9 && c[1] < 0.1, "{c:?}");
        let c = payloads.render_pixel(75.0, 50.0, Some(tex), false);
        assert!(c[1] > 0.9 && c[0] < 0.1, "{c:?}");
    }

    /// 内存位图：闭包写入像素数组（functional_trait 的 AsBitmap），返回像素数组供断言
    fn test_bitmap<F: FnOnce(&mut dyn AsBitmap)>(w: usize, h: usize, run: F) -> Vec<[f32; 4]> {
        let mut pixels = vec![[0.0, 0.0, 0.0, 0.0]; w * h];
        run(&mut |x: usize, y: usize, rgba: [f32; 4]| {
            pixels[y * w + x] = rgba;
        });
        pixels
    }
    #[test]
    fn render_bitmap_fills_triangle_bbox() {
        // 8×8 位图，half_extent=100：模型 (0,0)-(100,100) 正方形
        // 对应位图 col 4..8（x=0 -> col 4，x=100 -> col 8），row 0..4（y=100 -> row 0，y=0 -> row 4）
        let mut payloads = vec![square_payload(Vec2::new(0.0, 0.0), Vec2::new(100.0, 100.0))];
        payloads[0].tint_color = [1.0, 0.0, 0.0, 1.0];
        let pixels = test_bitmap(8, 8, |bmp| {
            payloads.render_bitmap(8, 8, Vec2::splat(100.0), Vec2::ZERO, None::<&dyn AsTexture>, false, bmp);
        });
        // 正方形内部像素 -> 红色；外部 -> 透明黑（get(5,1) = pixels[1*8+5]）
        assert!(pixels[8 + 5][0] > 0.9, "{:?}", pixels[8 + 5]);
        assert!(
            pixels[2 * 8 + 2][3] == 0.0,
            "外部应透明: {:?}",
            pixels[2 * 8 + 2]
        );
        assert!(pixels[3 * 8 + 7][0] > 0.9, "{:?}", pixels[3 * 8 + 7]);
        assert!(
            pixels[5 * 8 + 1][3] == 0.0,
            "外部应透明: {:?}",
            pixels[5 * 8 + 1]
        );
        // offset 位移：视口中心移到 (100, 100)，正方形 (0,0)-(100,100) 映射到 col 0..4、row 3..8
        let pixels = test_bitmap(8, 8, |bmp| {
            payloads.render_bitmap(
                8,
                8,
                Vec2::splat(100.0),
                Vec2::new(100.0, 100.0),
                None::<&dyn AsTexture>,
                false,
                bmp,
            );
        });
        assert!(
            pixels[5 * 8 + 2][0] > 0.9,
            "位移后应命中: {:?}",
            pixels[5 * 8 + 2]
        );
        assert!(
            pixels[8 + 6][3] == 0.0,
            "位移后外部应透明: {:?}",
            pixels[8 + 6]
        );
    }

    #[test]
    fn render_bitmap_later_payload_overwrites() {
        // 红底 + 蓝小方块，靠后的蓝覆盖红
        let mut red = square_payload(Vec2::new(-100.0, -100.0), Vec2::new(100.0, 100.0));
        red.tint_color = [1.0, 0.0, 0.0, 1.0];
        let mut blue = square_payload(Vec2::new(-25.0, -25.0), Vec2::new(25.0, 25.0));
        blue.tint_color = [0.0, 0.0, 1.0, 1.0];
        let payloads = vec![red, blue];
        let pixels = test_bitmap(8, 8, |bmp| {
            payloads.render_bitmap(8, 8, Vec2::splat(100.0), Vec2::ZERO, None::<&dyn AsTexture>, false, bmp);
        });
        // 中心 (col 4, row 4) -> 蓝；角落 (col 1, row 1) -> 红
        assert!(
            pixels[4 * 8 + 4][2] > 0.9 && pixels[4 * 8 + 4][0] < 0.1,
            "{:?}",
            pixels[4 * 8 + 4]
        );
        assert!(
            pixels[8 + 1][0] > 0.9 && pixels[8 + 1][2] < 0.1,
            "{:?}",
            pixels[8 + 1]
        );
    }

    #[test]
    fn render_bitmap_blends_transparent_over_opaque() {
        // 红底 + 靠后的半透明蓝：中心应为混合色（且不为空洞），而不是被透明像素挖掉
        let mut red = square_payload(Vec2::new(-100.0, -100.0), Vec2::new(100.0, 100.0));
        red.tint_color = [1.0, 0.0, 0.0, 1.0];
        let mut blue = square_payload(Vec2::new(-50.0, -50.0), Vec2::new(50.0, 50.0));
        blue.tint_color = [0.0, 0.0, 1.0, 0.5];
        let payloads = vec![red, blue];
        let pixels = test_bitmap(8, 8, |bmp| {
            payloads.render_bitmap(8, 8, Vec2::splat(100.0), Vec2::ZERO, None::<&dyn AsTexture>, false, bmp);
        });
        let c = pixels[4 * 8 + 4];
        // 中心：蓝 0.5 叠在红上 -> rgb=(0.5, 0, 0.5)，alpha=1
        assert!(c[3] > 0.99, "alpha 应不透明: {c:?}");
        assert!(
            (c[0] - 0.5).abs() < 0.1 && (c[2] - 0.5).abs() < 0.1,
            "{c:?}"
        );
        // 角落：只有红
        assert!(
            pixels[8 + 1][0] > 0.9 && pixels[8 + 1][3] > 0.99,
            "{:?}",
            pixels[8 + 1]
        );
        // render_pixel 同样混合
        let c = payloads.render_pixel(0.0, 0.0, None::<&dyn AsTexture>, false);
        assert!(
            c[3] > 0.99 && (c[0] - 0.5).abs() < 0.1 && (c[2] - 0.5).abs() < 0.1,
            "{c:?}"
        );
    }

    #[test]
    fn aabb_covers_all_meshes() {
        // 空列表 -> None
        let payloads: Vec<MeshPayload> = Vec::new();
        assert_eq!(payloads.aabb(), None);
        // 两个正方形：(-100,-100)-(100,100) 与 (200,300)-(400,500)
        let a = square_payload(Vec2::new(-100.0, -100.0), Vec2::new(100.0, 100.0));
        let b = square_payload(Vec2::new(200.0, 300.0), Vec2::new(400.0, 500.0));
        let payloads = vec![a, b];
        let (min, max) = payloads.aabb().unwrap();
        assert!((min.x - (-100.0)).abs() < 1e-4, "{min:?}");
        assert!((min.y - (-100.0)).abs() < 1e-4, "{min:?}");
        assert!((max.x - 400.0).abs() < 1e-4, "{max:?}");
        assert!((max.y - 500.0).abs() < 1e-4, "{max:?}");
    }

    /// render_tint：不采样纹理，输出纯 tint 剪影；命中像素 = tint 色，背景保持透明
    #[test]
    fn render_tint_produces_silhouette() {
        // 不透明蓝正方形（tint 0,0,1,1），只占视口中部
        let mut blue = square_payload(Vec2::new(-50.0, -50.0), Vec2::new(50.0, 50.0));
        blue.tint_color = [0.0, 0.0, 1.0, 1.0];
        let payloads = vec![blue];
        let pixels = test_bitmap(8, 8, |bmp| {
            payloads.render_tint(8, 8, Vec2::splat(100.0), Vec2::ZERO, bmp);
        });
        // 中心命中：tint 蓝（无纹理叠加）
        let c = pixels[4 * 8 + 4];
        assert!((c[2] - 1.0).abs() < 0.1 && c[0] < 0.1, "{c:?}");
        assert!(c[3] > 0.99, "{c:?}");
        // 角落（视口边缘，正方形外）：透明（未写像素）
        assert!(pixels[8 + 1][3] == 0.0, "{:?}", pixels[8 + 1]);
        // 与显式传 None 纹理的 render_bitmap 结果一致
        let pixels2 = test_bitmap(8, 8, |bmp| {
            payloads.render_bitmap(8, 8, Vec2::splat(100.0), Vec2::ZERO, None::<&dyn AsTexture>, false, bmp);
        });
        assert_eq!(pixels, pixels2);
    }

    /// render_bitmap / render_pixel 的预乘 alpha 模式：
    /// 预乘纹理（rgb 已乘过 alpha）渲染结果与等价的直通纹理完全一致（输出均为直通 alpha），
    /// 验证 `premultiplied_alpha=true` 时混合与输出转换正确
    #[test]
    fn render_premultiplied_matches_straight() {
        let mut payloads = vec![square_payload(Vec2::new(0.0, 0.0), Vec2::new(100.0, 100.0))];
        // 半透明 tint：直通模式与预乘模式都应正确叠加 tint 的 alpha
        payloads[0].tint_color = [1.0, 1.0, 1.0, 0.5];
        // 直通纹理：左半半透明紫 (0.8,0.2,0.4,0.5)、右半半透明青 (0.2,0.6,0.4,0.5)
        let straight: &dyn AsTexture = &|u: f32, _v: f32| -> [f32; 4] {
            if u < 0.5 {
                [0.8, 0.2, 0.4, 0.5]
            } else {
                [0.2, 0.6, 0.4, 0.5]
            }
        };
        // 预乘纹理：rgb 已乘过 alpha
        let premul: &dyn AsTexture = &|u: f32, _v: f32| -> [f32; 4] {
            if u < 0.5 {
                [0.4, 0.1, 0.2, 0.5]
            } else {
                [0.1, 0.3, 0.2, 0.5]
            }
        };
        // 逐像素查询：两种模式输出一致
        for x in [25.0, 75.0] {
            let a = payloads.render_pixel(x, 50.0, Some(straight), false);
            let b = payloads.render_pixel(x, 50.0, Some(premul), true);
            for i in 0..4 {
                assert!(
                    (a[i] - b[i]).abs() < 1e-4,
                    "straight {a:?} vs premul {b:?} at x={x}"
                );
            }
        }
        // 位图光栅化：两种模式输出一致
        let px_s = test_bitmap(8, 8, |bmp| {
            payloads.render_bitmap(8, 8, Vec2::splat(100.0), Vec2::ZERO, Some(straight), false, bmp);
        });
        let px_p = test_bitmap(8, 8, |bmp| {
            payloads.render_bitmap(8, 8, Vec2::splat(100.0), Vec2::ZERO, Some(premul), true, bmp);
        });
        for (s, p) in px_s.iter().zip(&px_p) {
            for i in 0..4 {
                assert!((s[i] - p[i]).abs() < 1e-4, "straight {s:?} vs premul {p:?}");
            }
        }
    }

    /// merge：无 clip 时全部合并成一组，索引偏移正确，渲染结果与合并前一致
    #[test]
    fn merge_meshes_combines_without_clip() {
        let mut payloads = vec![
            square_payload(Vec2::new(0.0, 0.0), Vec2::new(100.0, 100.0)),
            square_payload(Vec2::new(100.0, 0.0), Vec2::new(200.0, 100.0)),
        ];
        let before = payloads.render_pixel(150.0, 50.0, None::<&dyn AsTexture>, false);
        payloads.merge_meshes(false);
        assert_eq!(payloads.len(), 1);
        let m = &payloads[0];
        assert_eq!(m.positions.len(), 8);
        assert_eq!(m.uvs.len(), 8);
        assert_eq!(m.indices.len(), 12);
        // 索引已按顶点偏移修正：不会越过合并后的顶点池
        for &i in &m.indices {
            assert!((i as usize) < m.positions.len(), "index {i} out of range");
        }
        // 合并前后渲染一致（同 tint 合并成一组的渲染等价）
        let after = payloads.render_pixel(150.0, 50.0, None::<&dyn AsTexture>, false);
        assert_eq!(before, after);
    }

    /// merge：separate_at_clip=true 时 clip 区域内/外分属不同组；false 时忽略指令全合并
    #[test]
    fn merge_meshes_separates_at_clip() {
        let clip_polygon = vec![
            Vec2::new(0.0, 0.0),
            Vec2::new(50.0, 0.0),
            Vec2::new(50.0, 50.0),
            Vec2::new(0.0, 50.0),
        ];
        let clip_start = || {
            MeshPayload::new(
                PayloadUsage::ClipStart {
                    id: unsafe { crate::custom_index::AsIndex::from_index(0) },
                },
                unsafe { crate::custom_index::AsIndex::from_index(0) },
                clip_polygon.clone(),
                Vec::new(),
                Vec::new(),
                [1.0; 4],
                glam::Affine2::IDENTITY,
            )
        };
        let clip_end = || {
            MeshPayload::new(
                PayloadUsage::ClipEnd {
                    id: unsafe { crate::custom_index::AsIndex::from_index(0) },
                },
                unsafe { crate::custom_index::AsIndex::from_index(0) },
                Vec::new(),
                Vec::new(),
                Vec::new(),
                [1.0; 4],
                glam::Affine2::IDENTITY,
            )
        };
        let inner = square_payload(Vec2::new(0.0, 0.0), Vec2::new(50.0, 50.0));
        let outer = square_payload(Vec2::new(100.0, 100.0), Vec2::new(200.0, 200.0));

        // separate=true：clip 内（depth 1）与 clip 外（depth 0）分两组
        let mut payloads = vec![clip_start(), inner.clone(), clip_end(), outer.clone()];
        payloads.merge_meshes(true);
        assert_eq!(payloads.len(), 2, "clip 内外应分开: {:?}", payloads.len());

        // separate=false：忽略 clip 指令，全部合成一组
        let mut payloads = vec![clip_start(), inner, clip_end(), outer];
        payloads.merge_meshes(false);
        assert_eq!(payloads.len(), 1);
        assert_eq!(payloads[0].positions.len(), 8);
    }

    /// merge：不同 tint 的网格分属不同组（合并不能破坏每个网格的颜色）
    #[test]
    fn merge_meshes_groups_by_tint() {
        let mut a = square_payload(Vec2::new(0.0, 0.0), Vec2::new(100.0, 100.0));
        a.tint_color = [1.0, 0.0, 0.0, 1.0];
        let mut b = square_payload(Vec2::new(100.0, 100.0), Vec2::new(200.0, 200.0));
        b.tint_color = [0.0, 0.0, 1.0, 1.0];
        let mut payloads = vec![a, b];
        payloads.merge_meshes(false);
        assert_eq!(payloads.len(), 2, "不同 tint 应分成独立组");
        // 每组保持自己的 tint 与几何
        let (red, blue) = if payloads[0].tint_color[0] > 0.9 {
            (&payloads[0], &payloads[1])
        } else {
            (&payloads[1], &payloads[0])
        };
        assert!(red.tint_color[0] > 0.9 && red.positions.len() == 4);
        assert!(blue.tint_color[2] > 0.9 && blue.positions.len() == 4);
        // 合并后各点渲染颜色与合并前一致
        let c0 = payloads.render_pixel(50.0, 50.0, None::<&dyn AsTexture>, false);
        assert!(c0[0] > 0.9 && c0[2] < 0.1, "{c0:?}");
        let c1 = payloads.render_pixel(150.0, 150.0, None::<&dyn AsTexture>, false);
        assert!(c1[2] > 0.9 && c1[0] < 0.1, "{c1:?}");
    }

    /// merge：合并时把 uv_transform 应用进 uvs（结果统一 identity），不同变换的网格也能合并
    #[test]
    fn merge_meshes_applies_uv_transform() {
        let mut a = square_payload(Vec2::new(0.0, 0.0), Vec2::new(100.0, 100.0));
        a.uv_transform = glam::Affine2::from_scale(Vec2::splat(2.0));
        let mut b = square_payload(Vec2::new(100.0, 100.0), Vec2::new(200.0, 200.0));
        b.uv_transform = glam::Affine2::from_scale(Vec2::splat(3.0));
        let mut payloads = vec![a, b];
        payloads.merge_meshes(false);
        assert_eq!(payloads.len(), 1, "uv_transform 应用掉后不同变换的网格可合并");
        let m = &payloads[0];
        assert_eq!(m.uv_transform, glam::Affine2::IDENTITY);
        // square_payload uvs = [(0,0),(1,0),(1,1),(0,1)]：a 乘 2、b 乘 3
        assert_eq!(m.uvs[0], Vec2::new(0.0, 0.0));
        assert_eq!(m.uvs[1], Vec2::new(2.0, 0.0));
        assert_eq!(m.uvs[2], Vec2::new(2.0, 2.0));
        assert_eq!(m.uvs[4], Vec2::new(0.0, 0.0));
        assert_eq!(m.uvs[5], Vec2::new(3.0, 0.0));
        assert_eq!(m.uvs[6], Vec2::new(3.0, 3.0));
    }

    /// merge：嵌套裁剪（separate=true）时每层 clip 各一组 + 最外层一组
    #[test]
    fn merge_meshes_nested_clip_layers() {
        let poly = || {
            vec![
                Vec2::new(0.0, 0.0),
                Vec2::new(50.0, 0.0),
                Vec2::new(50.0, 50.0),
                Vec2::new(0.0, 50.0),
            ]
        };
        let clip_start = || {
            MeshPayload::new(
                PayloadUsage::ClipStart {
                    id: unsafe { crate::custom_index::AsIndex::from_index(0) },
                },
                unsafe { crate::custom_index::AsIndex::from_index(0) },
                poly(),
                Vec::new(),
                Vec::new(),
                [1.0; 4],
                glam::Affine2::IDENTITY,
            )
        };
        let clip_end = || {
            MeshPayload::new(
                PayloadUsage::ClipEnd {
                    id: unsafe { crate::custom_index::AsIndex::from_index(0) },
                },
                unsafe { crate::custom_index::AsIndex::from_index(0) },
                Vec::new(),
                Vec::new(),
                Vec::new(),
                [1.0; 4],
                glam::Affine2::IDENTITY,
            )
        };
        let mesh = || square_payload(Vec2::new(0.0, 0.0), Vec2::new(50.0, 50.0));
        // 外 -> clip1 内 -> clip2（嵌套）内 -> clip2 结束 -> clip1 结束 -> 外
        let mut payloads = vec![
            mesh(),
            clip_start(),
            mesh(),
            clip_start(),
            mesh(),
            clip_end(),
            clip_end(),
            mesh(),
        ];
        payloads.merge_meshes(true);
        // 3 组：depth0（首尾两个 mesh 合并为 8 顶点）、depth1（4 顶点）、depth2（4 顶点）
        assert_eq!(payloads.len(), 3, "应为 3 组（外/层1/层2）: {}", payloads.len());
        let mut sizes: Vec<usize> = payloads.iter().map(|p| p.positions.len()).collect();
        sizes.sort_unstable();
        assert_eq!(sizes, vec![4, 4, 8], "{sizes:?}");
    }
}