//go:build gl

// 覆盖层渲染：破坏裂纹叠加（destroy_stage_0..9）与第一人称手持方块
// （方块交互与动画.md §4、渲染.md §5.2）。
// 与区块网格共用顶点格式（pos+uv+light）与着色器，通过 uOffset 平移定位。
package render

import (
	"image"
	"math"
	"unsafe"

	"mc/internal/mesh"

	"github.com/go-gl/gl/v3.3-core/gl"
)

// cubeFaces 单位立方体 6 面角顺序（与 mesh.faceDef 一致，
// 窗口空间 CW 绕序为 FrontFace(CW) 的正面；窗口坐标 y 向上）。
var cubeFaces = [6][4][3]float32{
	{{0, 1, 0}, {1, 1, 0}, {1, 1, 1}, {0, 1, 1}}, // 顶
	{{0, 0, 1}, {1, 0, 1}, {1, 0, 0}, {0, 0, 0}}, // 底
	{{1, 0, 0}, {1, 0, 1}, {1, 1, 1}, {1, 1, 0}}, // 东(+x)
	{{0, 0, 1}, {0, 0, 0}, {0, 1, 0}, {0, 1, 1}}, // 西(-x)
	{{1, 0, 1}, {0, 0, 1}, {0, 1, 1}, {1, 1, 1}}, // 南(+z)
	{{0, 0, 0}, {1, 0, 0}, {1, 1, 0}, {0, 1, 0}}, // 北(-z)
}

// cubeVerts 按六面 UV 构建单位立方体顶点（mesh.Vertex 格式：pos+uv+light 字节，
// 光照满亮——覆盖层不受世界光照影响）。inflate 沿角外扩（裂纹盒防 z-fighting）。
func cubeVerts(uvs [6][4]float32, inflate float32) []mesh.Vertex {
	var verts []mesh.Vertex
	for fi, face := range cubeFaces {
		u0, v0, u1, v1 := uvs[fi][0], uvs[fi][1], uvs[fi][2], uvs[fi][3]
		for _, c := range face {
			// 角 UV 权重（同 mesh.cornerUV）
			var cu, cv float32
			switch fi {
			case 0, 1: // 顶/底：x→u，z→v
				cu, cv = c[0], c[2]
			case 2, 3: // 东/西：z→u，y→v（v 翻转）
				cu, cv = c[2], 1-c[1]
			default: // 南/北：x→u，y→v（v 翻转）
				cu, cv = c[0], 1-c[1]
			}
			verts = append(verts, mesh.Vertex{
				X: (c[0]-0.5)*(1+inflate) + 0.5,
				Y: (c[1]-0.5)*(1+inflate) + 0.5,
				Z: (c[2]-0.5)*(1+inflate) + 0.5,
				U: u0 + (u1-u0)*cu, V: v0 + (v1-v0)*cv,
				Sky: 15, Block: 15,
			})
		}
	}
	return verts
}

// cubeIndices 24 顶点 → 36 索引（每面 2 三角形）。
func cubeIndices() []uint32 {
	idx := make([]uint32, 0, 36)
	for base := 0; base < 24; base += 4 {
		b := uint32(base)
		idx = append(idx, b, b+1, b+2, b+2, b+3, b)
	}
	return idx
}

// uploadMesh 上传顶点/索引并绑定顶点属性（chunk 顶点布局，渲染.md §5）。
func uploadMesh(verts []mesh.Vertex, idx []uint32) (vao, vbo, ibo uint32) {
	gl.GenVertexArrays(1, &vao)
	gl.GenBuffers(1, &vbo)
	gl.GenBuffers(1, &ibo)
	gl.BindVertexArray(vao)
	gl.BindBuffer(gl.ARRAY_BUFFER, vbo)
	gl.BufferData(gl.ARRAY_BUFFER, len(verts)*int(unsafe.Sizeof(mesh.Vertex{})), gl.Ptr(verts), gl.STATIC_DRAW)
	gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, ibo)
	gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, len(idx)*4, gl.Ptr(idx), gl.STATIC_DRAW)
	stride := int32(unsafe.Sizeof(mesh.Vertex{}))
	gl.EnableVertexAttribArray(0)
	gl.VertexAttribPointer(0, 3, gl.FLOAT, false, stride, gl.PtrOffset(0))
	gl.EnableVertexAttribArray(1)
	gl.VertexAttribPointer(1, 2, gl.FLOAT, false, stride, gl.PtrOffset(3*4))
	gl.EnableVertexAttribArray(2)
	gl.VertexAttribPointer(2, 2, gl.UNSIGNED_BYTE, false, stride, gl.PtrOffset(5*4))
	gl.BindVertexArray(0)
	return
}

// buildCubeVAO 构建立方体 VAO（顶点格式与 chunk 一致：pos+uv+light）。
// uvs 六面 UV（顺序同 cubeFaces）；inflate 沿角外扩；立方体锚点为原点，边长为 1。
func buildCubeVAO(uvs [6][4]float32, inflate float32) uint32 {
	vao, _, _ := uploadMesh(cubeVerts(uvs, inflate), cubeIndices())
	return vao
}

// SetCrackAtlas 上传裂纹图集（10 阶段 destroy_stage）并记录各阶段 UV。
// img 为调用方打包好的图集，rects[i] 为阶段 i 的像素矩形（图集坐标系）。
func (r *Renderer) SetCrackAtlas(img image.Image, rects [10]image.Rectangle) {
	if r.crackTex == 0 {
		gl.GenTextures(1, &r.crackTex)
	}
	gl.BindTexture(gl.TEXTURE_2D, r.crackTex)
	b := img.Bounds()
	gl.TexImage2D(gl.TEXTURE_2D, 0, gl.RGBA8, int32(b.Dx()), int32(b.Dy()), 0, gl.RGBA, gl.UNSIGNED_BYTE, gl.Ptr(imageBytes(img)))
	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.NEAREST)
	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.NEAREST)
	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE)
	gl.TexParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE)

	W, H := float32(b.Dx()), float32(b.Dy())
	const inset = 0.5 // 防渗色（渲染.md §4）
	for i, rc := range rects {
		r.crackUVs[i] = [4]float32{
			(float32(rc.Min.X) + inset) / W, (float32(rc.Min.Y) + inset) / H,
			(float32(rc.Max.X) - inset) / W, (float32(rc.Max.Y) - inset) / H,
		}
	}
}

// DrawCrackOverlay 在目标方块 (x,y,z) 叠加 stage 阶段裂纹盒
// （方块交互与动画.md §4：0–9，六面同图，盒体略外扩防 z-fighting）。
func (r *Renderer) DrawCrackOverlay(x, y, z float32, stage int) {
	if r.crackTex == 0 {
		return
	}
	if stage < 0 {
		stage = 0
	}
	if stage > 9 {
		stage = 9
	}
	if r.crackCubes[stage] == 0 {
		uv := r.crackUVs[stage]
		r.crackCubes[stage] = buildCubeVAO([6][4]float32{uv, uv, uv, uv, uv, uv}, 0.004)
	}

	gl.UseProgram(r.prog)
	gl.ActiveTexture(gl.TEXTURE0)
	gl.BindTexture(gl.TEXTURE_2D, r.crackTex)
	vpLoc := gl.GetUniformLocation(r.prog, gl.Str("uViewProj\x00"))
	var vp [16]float32
	multiply4(&vp, &r.proj, &r.view)
	gl.UniformMatrix4fv(vpLoc, 1, false, &vp[0])
	offLoc := gl.GetUniformLocation(r.prog, gl.Str("uOffset\x00"))
	gl.Uniform3f(offLoc, x, y, z)
	cutLoc := gl.GetUniformLocation(r.prog, gl.Str("uCutout\x00"))
	gl.Uniform1f(cutLoc, 0)
	billLoc := gl.GetUniformLocation(r.prog, gl.Str("uBill\x00"))
	gl.Uniform2f(billLoc, 1, 0) // 非广告牌路径
	uvMinLoc := gl.GetUniformLocation(r.prog, gl.Str("uUVMin\x00"))
	uvMaxLoc := gl.GetUniformLocation(r.prog, gl.Str("uUVMax\x00"))
	gl.Uniform2f(uvMinLoc, 0, 0)
	gl.Uniform2f(uvMaxLoc, 1, 1)
	tintLoc := gl.GetUniformLocation(r.prog, gl.Str("uTint\x00"))
	gl.Uniform4f(tintLoc, 1, 1, 1, 1)

	gl.Enable(gl.POLYGON_OFFSET_FILL)
	gl.PolygonOffset(-1, -1)
	gl.BindVertexArray(r.crackCubes[stage])
	gl.DrawElements(gl.TRIANGLES, 36, gl.UNSIGNED_INT, gl.PtrOffset(0))
	gl.BindVertexArray(0)
	gl.Disable(gl.POLYGON_OFFSET_FILL)
	gl.Uniform3f(offLoc, 0, 0, 0) // 复位平移（后续绘制依赖 0 偏移）
}

// SetHandCube 上传/更新手持方块立方体（六面 UV 顺序同 cubeFaces）。
// pos/scale 为视图空间下的立方体中心与边长（渲染.md §5.2）。
func (r *Renderer) SetHandCube(uvs [6][4]float32, pos [3]float32, scale float32) {
	r.ClearHand()
	// 直接按视图空间坐标构建顶点（顶点含 pos 偏移）
	var verts []mesh.Vertex
	for fi, face := range cubeFaces {
		u0, v0, u1, v1 := uvs[fi][0], uvs[fi][1], uvs[fi][2], uvs[fi][3]
		for _, c := range face {
			var cu, cv float32
			switch fi {
			case 0, 1:
				cu, cv = c[0], c[2]
			case 2, 3:
				cu, cv = c[2], 1-c[1]
			default:
				cu, cv = c[0], 1-c[1]
			}
			verts = append(verts, mesh.Vertex{
				X: pos[0] + (c[0]-0.5)*scale,
				Y: pos[1] + (c[1]-0.5)*scale,
				Z: pos[2] + (c[2]-0.5)*scale,
				U: u0 + (u1-u0)*cu, V: v0 + (v1-v0)*cv,
				Sky: 15, Block: 15,
			})
		}
	}
	r.handVao, r.handVbo, r.handIbo = uploadMesh(verts, cubeIndices())
}

// ClearHand 释放手持方块网格（手持物品为空时调用）。
func (r *Renderer) ClearHand() {
	if r.handVao != 0 {
		gl.DeleteVertexArrays(1, &r.handVao)
		r.handVao = 0
	}
	if r.handVbo != 0 {
		gl.DeleteBuffers(1, &r.handVbo)
		r.handVbo = 0
	}
	if r.handIbo != 0 {
		gl.DeleteBuffers(1, &r.handIbo)
		r.handIbo = 0
	}
}

// DrawHand 绘制手持方块（顶点已是视图空间，仅乘投影矩阵；tint 肤色乘数）。
func (r *Renderer) DrawHand(tint [3]float32) {
	if r.handVao == 0 {
		return
	}
	gl.UseProgram(r.prog)
	gl.ActiveTexture(gl.TEXTURE0)
	gl.BindTexture(gl.TEXTURE_2D, r.atlas)
	vpLoc := gl.GetUniformLocation(r.prog, gl.Str("uViewProj\x00"))
	gl.UniformMatrix4fv(vpLoc, 1, false, &r.proj[0])
	offLoc := gl.GetUniformLocation(r.prog, gl.Str("uOffset\x00"))
	gl.Uniform3f(offLoc, 0, 0, 0)
	cutLoc := gl.GetUniformLocation(r.prog, gl.Str("uCutout\x00"))
	gl.Uniform1f(cutLoc, 0)
	billLoc := gl.GetUniformLocation(r.prog, gl.Str("uBill\x00"))
	gl.Uniform2f(billLoc, 1, 0)
	uvMinLoc := gl.GetUniformLocation(r.prog, gl.Str("uUVMin\x00"))
	uvMaxLoc := gl.GetUniformLocation(r.prog, gl.Str("uUVMax\x00"))
	gl.Uniform2f(uvMinLoc, 0, 0)
	gl.Uniform2f(uvMaxLoc, 1, 1)
	tintLoc := gl.GetUniformLocation(r.prog, gl.Str("uTint\x00"))
	gl.Uniform4f(tintLoc, tint[0], tint[1], tint[2], 1)
	gl.BindVertexArray(r.handVao)
	gl.DrawElements(gl.TRIANGLES, 36, gl.UNSIGNED_INT, gl.PtrOffset(0))
	gl.BindVertexArray(0)
}

// ensureHandItemQuad 惰性构建手持物品四边形 VAO（顶点每帧重传：位置随挥动变化）。
func (r *Renderer) ensureHandItemQuad() {
	if r.handItemVao != 0 {
		return
	}
	gl.GenVertexArrays(1, &r.handItemVao)
	gl.GenBuffers(1, &r.handItemVbo)
	gl.GenBuffers(1, &r.handItemIbo)
	gl.BindVertexArray(r.handItemVao)
	gl.BindBuffer(gl.ARRAY_BUFFER, r.handItemVbo)
	stride := int32(unsafe.Sizeof(mesh.Vertex{}))
	gl.EnableVertexAttribArray(0)
	gl.VertexAttribPointer(0, 3, gl.FLOAT, false, stride, gl.PtrOffset(0))
	gl.EnableVertexAttribArray(1)
	gl.VertexAttribPointer(1, 2, gl.FLOAT, false, stride, gl.PtrOffset(3*4))
	gl.EnableVertexAttribArray(2)
	gl.VertexAttribPointer(2, 2, gl.UNSIGNED_BYTE, false, stride, gl.PtrOffset(5*4))
	idx := []uint32{0, 1, 2, 0, 2, 3}
	gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, r.handItemIbo)
	gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, len(idx)*4, gl.Ptr(idx), gl.STATIC_DRAW)
	gl.BindVertexArray(0)
}

// DrawHandItem 绘制手持物品图标（非放置物品，如工具/食物）：视图空间小四边形，
// 轻微倾斜（原版手持角度），双面、alpha test，贴实体图集内物品贴图（渲染.md §5.2）。
// pos 为视图空间中心，scale 为边长。
func (r *Renderer) DrawHandItem(uv [4]float32, pos [3]float32, scale float32) {
	if r.entityTex == 0 {
		return
	}
	r.ensureHandItemQuad()

	// 四角局部坐标（-0.5..0.5），绕 Y 转 yaw、绕 X 抬 pitch（烘焙进视图空间顶点）
	const yaw, pitch = -0.6, 0.25
	cy, sy := float32(math.Cos(yaw)), float32(math.Sin(yaw))
	cp, sp := float32(math.Cos(pitch)), float32(math.Sin(pitch))
	corners := [4][2]float32{{-0.5, -0.5}, {0.5, -0.5}, {0.5, 0.5}, {-0.5, 0.5}}
	verts := make([]mesh.Vertex, 0, 4)
	for _, c := range corners {
		lx, ly := c[0]*scale, c[1]*scale
		rx := lx * cy
		rz := -lx * sy
		ry := ly*cp - rz*sp
		rz2 := ly*sp + rz*cp
		verts = append(verts, mesh.Vertex{
			X: pos[0] + rx, Y: pos[1] + ry, Z: pos[2] + rz2,
			U: c[0] + 0.5, V: 0.5 - c[1], // 图集 tile：v=0 为图像顶，图标保持正立
			Sky: 15, Block: 15,
		})
	}
	gl.BindBuffer(gl.ARRAY_BUFFER, r.handItemVbo)
	gl.BufferData(gl.ARRAY_BUFFER, len(verts)*int(unsafe.Sizeof(mesh.Vertex{})), gl.Ptr(verts), gl.DYNAMIC_DRAW)

	gl.UseProgram(r.prog)
	gl.ActiveTexture(gl.TEXTURE0)
	gl.BindTexture(gl.TEXTURE_2D, r.entityTex)
	gl.UniformMatrix4fv(gl.GetUniformLocation(r.prog, gl.Str("uViewProj\x00")), 1, false, &r.proj[0])
	gl.Uniform3f(gl.GetUniformLocation(r.prog, gl.Str("uOffset\x00")), 0, 0, 0)
	gl.Uniform1f(gl.GetUniformLocation(r.prog, gl.Str("uCutout\x00")), 1) // alpha test 剔透明
	gl.Uniform4f(gl.GetUniformLocation(r.prog, gl.Str("uTint\x00")), 1, 1, 1, 1)
	gl.Uniform2f(gl.GetUniformLocation(r.prog, gl.Str("uBill\x00")), 1, 0)
	gl.Uniform2f(gl.GetUniformLocation(r.prog, gl.Str("uUVMin\x00")), uv[0], uv[1])
	gl.Uniform2f(gl.GetUniformLocation(r.prog, gl.Str("uUVMax\x00")), uv[2], uv[3])

	gl.Disable(gl.CULL_FACE) // 双面（背面为图标反相）
	gl.BindVertexArray(r.handItemVao)
	gl.DrawElements(gl.TRIANGLES, 6, gl.UNSIGNED_INT, gl.PtrOffset(0))
	gl.BindVertexArray(0)
	gl.Enable(gl.CULL_FACE)
	gl.Uniform2f(gl.GetUniformLocation(r.prog, gl.Str("uUVMin\x00")), 0, 0)
	gl.Uniform2f(gl.GetUniformLocation(r.prog, gl.Str("uUVMax\x00")), 1, 1)
}

func rotX(p [3]float32, a float32) [3]float32 {
	c, s := float32(math.Cos(float64(a))), float32(math.Sin(float64(a)))
	return [3]float32{p[0], p[1]*c - p[2]*s, p[1]*s + p[2]*c}
}

func rotY(p [3]float32, a float32) [3]float32 {
	c, s := float32(math.Cos(float64(a))), float32(math.Sin(float64(a)))
	return [3]float32{p[0]*c + p[2]*s, p[1], -p[0]*s + p[2]*c}
}

func rotZ(p [3]float32, a float32) [3]float32 {
	c, s := float32(math.Cos(float64(a))), float32(math.Sin(float64(a)))
	return [3]float32{p[0]*c - p[1]*s, p[0]*s + p[1]*c, p[2]}
}

func add3(a, b [3]float32) [3]float32 { return [3]float32{a[0] + b[0], a[1] + b[1], a[2] + b[2]} }

func swingChop(swing float32) float32 {
	if swing <= 0 {
		return 0
	}
	t := 1 - swing
	if t < 0.45 {
		return t / 0.45 * 1.15
	}
	return (1 - (t-0.45)/0.55) * 1.15
}

func mapSkinUV(tile [4]float32, uv [4]float32) [4]float32 {
	tw, th := tile[2]-tile[0], tile[3]-tile[1]
	return [4]float32{
		tile[0] + uv[0]*tw, tile[1] + uv[1]*th,
		tile[0] + uv[2]*tw, tile[1] + uv[3]*th,
	}
}

func appendBox(verts []mesh.Vertex, uvs [6][4]float32, xf func([3]float32) [3]float32) []mesh.Vertex {
	for fi, face := range cubeFaces {
		u0, v0, u1, v1 := uvs[fi][0], uvs[fi][1], uvs[fi][2], uvs[fi][3]
		for _, c := range face {
			var cu, cv float32
			switch fi {
			case 0, 1:
				cu, cv = c[0], c[2]
			case 2, 3:
				cu, cv = c[2], 1-c[1]
			default:
				cu, cv = c[0], 1-c[1]
			}
			p := xf([3]float32{c[0], c[1], c[2]})
			verts = append(verts, mesh.Vertex{
				X: p[0], Y: p[1], Z: p[2],
				U: u0 + (u1-u0)*cu, V: v0 + (v1-v0)*cv,
				Sky: 15, Block: 15,
			})
		}
	}
	return verts
}

func (r *Renderer) drawViewMesh(verts []mesh.Vertex, tex uint32, tint [3]float32, cutout float32) {
	if len(verts) == 0 {
		return
	}
	if r.animalVao == 0 {
		gl.GenVertexArrays(1, &r.animalVao)
		gl.GenBuffers(1, &r.animalVbo)
		gl.GenBuffers(1, &r.animalIbo)
		gl.BindVertexArray(r.animalVao)
		gl.BindBuffer(gl.ARRAY_BUFFER, r.animalVbo)
		stride := int32(unsafe.Sizeof(mesh.Vertex{}))
		gl.EnableVertexAttribArray(0)
		gl.VertexAttribPointer(0, 3, gl.FLOAT, false, stride, gl.PtrOffset(0))
		gl.EnableVertexAttribArray(1)
		gl.VertexAttribPointer(1, 2, gl.FLOAT, false, stride, gl.PtrOffset(3*4))
		gl.EnableVertexAttribArray(2)
		gl.VertexAttribPointer(2, 2, gl.UNSIGNED_BYTE, false, stride, gl.PtrOffset(5*4))
		gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, r.animalIbo)
		gl.BindVertexArray(0)
	}
	idx := make([]uint32, 0, len(verts)/4*6)
	for base := 0; base+3 < len(verts); base += 4 {
		b := uint32(base)
		idx = append(idx, b, b+1, b+2, b+2, b+3, b)
	}
	gl.BindBuffer(gl.ARRAY_BUFFER, r.animalVbo)
	gl.BufferData(gl.ARRAY_BUFFER, len(verts)*int(unsafe.Sizeof(mesh.Vertex{})), gl.Ptr(verts), gl.DYNAMIC_DRAW)
	gl.BindBuffer(gl.ELEMENT_ARRAY_BUFFER, r.animalIbo)
	gl.BufferData(gl.ELEMENT_ARRAY_BUFFER, len(idx)*4, gl.Ptr(idx), gl.DYNAMIC_DRAW)
	gl.UseProgram(r.prog)
	gl.ActiveTexture(gl.TEXTURE0)
	if tex != 0 {
		gl.BindTexture(gl.TEXTURE_2D, tex)
	}
	gl.UniformMatrix4fv(gl.GetUniformLocation(r.prog, gl.Str("uViewProj\x00")), 1, false, &r.proj[0])
	gl.Uniform3f(gl.GetUniformLocation(r.prog, gl.Str("uOffset\x00")), 0, 0, 0)
	gl.Uniform1f(gl.GetUniformLocation(r.prog, gl.Str("uCutout\x00")), cutout)
	gl.Uniform4f(gl.GetUniformLocation(r.prog, gl.Str("uTint\x00")), tint[0], tint[1], tint[2], 1)
	gl.Uniform2f(gl.GetUniformLocation(r.prog, gl.Str("uBill\x00")), 1, 0)
	gl.Uniform2f(gl.GetUniformLocation(r.prog, gl.Str("uUVMin\x00")), 0, 0)
	gl.Uniform2f(gl.GetUniformLocation(r.prog, gl.Str("uUVMax\x00")), 1, 1)
	gl.BindVertexArray(r.animalVao)
	gl.DrawElements(gl.TRIANGLES, int32(len(idx)), gl.UNSIGNED_INT, gl.PtrOffset(0))
	gl.BindVertexArray(0)
}

// DrawFirstPerson 第一人称右手：皮肤手臂 + 可选方块/挤出物品，绕肩挥动（渲染.md §5.2）。
func (r *Renderer) DrawFirstPerson(armTile [4]float32, hasSkin bool, swing float32, blockUVs [6][4]float32, hasBlock bool, itemUV [4]float32, hasItem bool) {
	shoulder := [3]float32{0.30, -0.18, -0.50}
	chop := swingChop(swing)
	xf := func(local [3]float32) [3]float32 {
		p := rotZ(rotX(local, 0.55), -0.38)
		p = rotX(p, -chop)
		return add3(p, shoulder)
	}

	armUVs := cuboidUV(40, 16, 4, 12, 4)
	if hasSkin {
		for i := range armUVs {
			armUVs[i] = mapSkinUV(armTile, armUVs[i])
		}
	}
	armVerts := appendBox(nil, armUVs, func(c [3]float32) [3]float32 {
		// 肩在 y=1，指尖朝 -Y；4×12×4 像素
		lx := (c[0] - 0.5) * 0.10
		ly := (c[1] - 1.0) * 0.30
		lz := (c[2] - 0.5) * 0.10
		return xf([3]float32{lx, ly, lz})
	})
	tint := [3]float32{1, 1, 1}
	tex := r.entityTex
	if !hasSkin {
		tint = [3]float32{0.85, 0.65, 0.5}
		if tex == 0 {
			tex = r.atlas
		}
	}
	r.drawViewMesh(armVerts, tex, tint, 0)

	if hasBlock {
		held := appendBox(nil, blockUVs, func(c [3]float32) [3]float32 {
			p := [3]float32{(c[0] - 0.5) * 0.16, (c[1] - 0.5) * 0.16, (c[2] - 0.5) * 0.16}
			p = rotY(rotX(p, 0.35), -0.55)
			p = add3(p, [3]float32{0.02, -0.30, 0.04})
			return xf(p)
		})
		r.drawViewMesh(held, r.atlas, [3]float32{1, 1, 1}, 0)
	}
	if hasItem && r.entityTex != 0 {
		u0, v0, u1, v1 := itemUV[0], itemUV[1], itemUV[2], itemUV[3]
		thick := float32(0.018)
		half := float32(0.11)
		corners := [4][2]float32{{-half, -half}, {half, -half}, {half, half}, {-half, half}}
		var verts []mesh.Vertex
		push := func(x, y, z, u, v float32) {
			p := rotY(rotX([3]float32{x, y, z}, 0.25), -0.55)
			p = add3(p, [3]float32{0.01, -0.30, 0.03})
			p = xf(p)
			verts = append(verts, mesh.Vertex{X: p[0], Y: p[1], Z: p[2], U: u, V: v, Sky: 15, Block: 15})
		}
		// 前
		push(corners[0][0], corners[0][1], thick, u0, v1)
		push(corners[1][0], corners[1][1], thick, u1, v1)
		push(corners[2][0], corners[2][1], thick, u1, v0)
		push(corners[3][0], corners[3][1], thick, u0, v0)
		// 后
		push(corners[1][0], corners[1][1], -thick, u0, v1)
		push(corners[0][0], corners[0][1], -thick, u1, v1)
		push(corners[3][0], corners[3][1], -thick, u1, v0)
		push(corners[2][0], corners[2][1], -thick, u0, v0)
		// 四边挤出（取边缘像素）
		edges := [][6]float32{
			{corners[0][0], corners[0][1], corners[1][0], corners[1][1], u0, v1},
			{corners[1][0], corners[1][1], corners[2][0], corners[2][1], u1, (v0 + v1) / 2},
			{corners[2][0], corners[2][1], corners[3][0], corners[3][1], u0, v0},
			{corners[3][0], corners[3][1], corners[0][0], corners[0][1], u0, (v0 + v1) / 2},
		}
		for _, e := range edges {
			push(e[0], e[1], thick, e[4], e[5])
			push(e[2], e[3], thick, e[4], e[5])
			push(e[2], e[3], -thick, e[4], e[5])
			push(e[0], e[1], -thick, e[4], e[5])
		}
		r.drawViewMesh(verts, r.entityTex, [3]float32{1, 1, 1}, 1)
	}
}