package skin_renderer

// generatePolygons 生成所有部件的多边形
func (r *SkinRenderer) generatePolygons() {
	r.polygons = make(map[string]map[string][]*Polygon)

	// 初始化各部件的面
	parts := []string{"helmet", "head", "torso", "rightArm", "leftArm", "rightLeg", "leftLeg"}
	faces := []string{"front", "back", "top", "bottom", "right", "left"}

	for _, part := range parts {
		r.polygons[part] = make(map[string][]*Polygon)
		for _, face := range faces {
			r.polygons[part][face] = []*Polygon{}
		}
	}

	hd := r.hdRatio

	// 生成头部多边形
	r.generateHeadPolygons(hd)

	// 生成头盔多边形
	r.generateHelmetPolygons(hd)

	if !r.headOnly {
		// 生成躯干多边形
		r.generateTorsoPolygons(hd)

		// 生成右臂多边形
		r.generateRightArmPolygons(hd)

		// 生成左臂多边形
		r.generateLeftArmPolygons(hd)

		// 生成右腿多边形
		r.generateRightLegPolygons(hd)

		// 生成左腿多边形
		r.generateLeftLegPolygons(hd)
	}
}

// generateHeadPolygons 生成头部多边形
func (r *SkinRenderer) generateHeadPolygons(hd int) {
	// 创建头部体积点
	volumePoints := make(map[int]map[int]map[int]*Point)

	for i := 0; i <= 8*hd; i++ {
		if volumePoints[i] == nil {
			volumePoints[i] = make(map[int]map[int]*Point)
		}
		for j := 0; j <= 8*hd; j++ {
			if volumePoints[i][j] == nil {
				volumePoints[i][j] = make(map[int]*Point)
			}
			// 前后面的点
			volumePoints[i][j][-2*hd] = NewPoint(float64(i), float64(j), float64(-2*hd))
			volumePoints[i][j][6*hd] = NewPoint(float64(i), float64(j), float64(6*hd))
		}
	}

	// 左右面的点
	for j := 0; j <= 8*hd; j++ {
		if volumePoints[0][j] == nil {
			volumePoints[0][j] = make(map[int]*Point)
		}
		if volumePoints[8*hd][j] == nil {
			volumePoints[8*hd][j] = make(map[int]*Point)
		}
		for k := -2 * hd; k <= 6*hd; k++ {
			if volumePoints[0][j][k] == nil {
				volumePoints[0][j][k] = NewPoint(0, float64(j), float64(k))
			}
			if volumePoints[8*hd][j][k] == nil {
				volumePoints[8*hd][j][k] = NewPoint(float64(8*hd), float64(j), float64(k))
			}
		}
	}

	// 上下面的点
	for i := 0; i <= 8*hd; i++ {
		if volumePoints[i] == nil {
			volumePoints[i] = make(map[int]map[int]*Point)
		}
		if volumePoints[i][0] == nil {
			volumePoints[i][0] = make(map[int]*Point)
		}
		if volumePoints[i][8*hd] == nil {
			volumePoints[i][8*hd] = make(map[int]*Point)
		}
		for k := -2 * hd; k <= 6*hd; k++ {
			if volumePoints[i][0][k] == nil {
				volumePoints[i][0][k] = NewPoint(float64(i), 0, float64(k))
			}
			if volumePoints[i][8*hd][k] == nil {
				volumePoints[i][8*hd][k] = NewPoint(float64(i), float64(8*hd), float64(k))
			}
		}
	}

	// 生成前后面多边形
	for i := 0; i < 8*hd; i++ {
		for j := 0; j < 8*hd; j++ {
			// 背面
			r.polygons["head"]["back"] = append(r.polygons["head"]["back"], NewPolygon(
				[4]*Point{
					volumePoints[i][j][-2*hd],
					volumePoints[i+1][j][-2*hd],
					volumePoints[i+1][j+1][-2*hd],
					volumePoints[i][j+1][-2*hd],
				},
				r.getPixelColor((32*hd-1)-i, 8*hd+j),
			))
			// 正面
			r.polygons["head"]["front"] = append(r.polygons["head"]["front"], NewPolygon(
				[4]*Point{
					volumePoints[i][j][6*hd],
					volumePoints[i+1][j][6*hd],
					volumePoints[i+1][j+1][6*hd],
					volumePoints[i][j+1][6*hd],
				},
				r.getPixelColor(8*hd+i, 8*hd+j),
			))
		}
	}

	// 生成左右面多边形
	for j := 0; j < 8*hd; j++ {
		for k := -2 * hd; k < 6*hd; k++ {
			// 右面
			r.polygons["head"]["right"] = append(r.polygons["head"]["right"], NewPolygon(
				[4]*Point{
					volumePoints[0][j][k],
					volumePoints[0][j][k+1],
					volumePoints[0][j+1][k+1],
					volumePoints[0][j+1][k],
				},
				r.getPixelColor(k+2*hd, 8*hd+j),
			))
			// 左面
			r.polygons["head"]["left"] = append(r.polygons["head"]["left"], NewPolygon(
				[4]*Point{
					volumePoints[8*hd][j][k],
					volumePoints[8*hd][j][k+1],
					volumePoints[8*hd][j+1][k+1],
					volumePoints[8*hd][j+1][k],
				},
				r.getPixelColor((24*hd-1)-k-2*hd, 8*hd+j),
			))
		}
	}

	// 生成上下面多边形
	for i := 0; i < 8*hd; i++ {
		for k := -2 * hd; k < 6*hd; k++ {
			// 顶面
			r.polygons["head"]["top"] = append(r.polygons["head"]["top"], NewPolygon(
				[4]*Point{
					volumePoints[i][0][k],
					volumePoints[i+1][0][k],
					volumePoints[i+1][0][k+1],
					volumePoints[i][0][k+1],
				},
				r.getPixelColor(8*hd+i, k+2*hd),
			))
			// 底面
			r.polygons["head"]["bottom"] = append(r.polygons["head"]["bottom"], NewPolygon(
				[4]*Point{
					volumePoints[i][8*hd][k],
					volumePoints[i+1][8*hd][k],
					volumePoints[i+1][8*hd][k+1],
					volumePoints[i][8*hd][k+1],
				},
				r.getPixelColor(16*hd+i, 2*hd+k),
			))
		}
	}
}

// generateHelmetPolygons 生成头盔/第二层多边形
func (r *SkinRenderer) generateHelmetPolygons(hd int) {
	// 头盔比头部稍大一点
	volumePoints := make(map[int]map[int]map[int]*Point)

	for i := 0; i <= 8*hd; i++ {
		if volumePoints[i] == nil {
			volumePoints[i] = make(map[int]map[int]*Point)
		}
		for j := 0; j <= 8*hd; j++ {
			if volumePoints[i][j] == nil {
				volumePoints[i][j] = make(map[int]*Point)
			}
			// 稍微放大
			volumePoints[i][j][-2*hd] = NewPoint(float64(i)*9/8-0.5*float64(hd), float64(j)*9/8-0.5*float64(hd), -2.5*float64(hd))
			volumePoints[i][j][6*hd] = NewPoint(float64(i)*9/8-0.5*float64(hd), float64(j)*9/8-0.5*float64(hd), 6.5*float64(hd))
		}
	}

	for j := 0; j <= 8*hd; j++ {
		if volumePoints[0][j] == nil {
			volumePoints[0][j] = make(map[int]*Point)
		}
		if volumePoints[8*hd][j] == nil {
			volumePoints[8*hd][j] = make(map[int]*Point)
		}
		for k := -2 * hd; k <= 6*hd; k++ {
			if volumePoints[0][j][k] == nil {
				volumePoints[0][j][k] = NewPoint(-0.5*float64(hd), float64(j)*9/8-0.5*float64(hd), float64(k)*9/8-0.5*float64(hd))
			}
			if volumePoints[8*hd][j][k] == nil {
				volumePoints[8*hd][j][k] = NewPoint(8.5*float64(hd), float64(j)*9/8-0.5*float64(hd), float64(k)*9/8-0.5*float64(hd))
			}
		}
	}

	for i := 0; i <= 8*hd; i++ {
		if volumePoints[i] == nil {
			volumePoints[i] = make(map[int]map[int]*Point)
		}
		if volumePoints[i][0] == nil {
			volumePoints[i][0] = make(map[int]*Point)
		}
		if volumePoints[i][8*hd] == nil {
			volumePoints[i][8*hd] = make(map[int]*Point)
		}
		for k := -2 * hd; k <= 6*hd; k++ {
			if volumePoints[i][0][k] == nil {
				volumePoints[i][0][k] = NewPoint(float64(i)*9/8-0.5*float64(hd), -0.5*float64(hd), float64(k)*9/8-0.5*float64(hd))
			}
			if volumePoints[i][8*hd][k] == nil {
				volumePoints[i][8*hd][k] = NewPoint(float64(i)*9/8-0.5*float64(hd), 8.5*float64(hd), float64(k)*9/8-0.5*float64(hd))
			}
		}
	}

	// 生成前后面多边形（头盔纹理偏移 32*hd）
	for i := 0; i < 8*hd; i++ {
		for j := 0; j < 8*hd; j++ {
			r.polygons["helmet"]["back"] = append(r.polygons["helmet"]["back"], NewPolygon(
				[4]*Point{
					volumePoints[i][j][-2*hd],
					volumePoints[i+1][j][-2*hd],
					volumePoints[i+1][j+1][-2*hd],
					volumePoints[i][j+1][-2*hd],
				},
				r.getPixelColor(32*hd+(32*hd-1)-i, 8*hd+j),
			))
			r.polygons["helmet"]["front"] = append(r.polygons["helmet"]["front"], NewPolygon(
				[4]*Point{
					volumePoints[i][j][6*hd],
					volumePoints[i+1][j][6*hd],
					volumePoints[i+1][j+1][6*hd],
					volumePoints[i][j+1][6*hd],
				},
				r.getPixelColor(32*hd+8*hd+i, 8*hd+j),
			))
		}
	}

	for j := 0; j < 8*hd; j++ {
		for k := -2 * hd; k < 6*hd; k++ {
			r.polygons["helmet"]["right"] = append(r.polygons["helmet"]["right"], NewPolygon(
				[4]*Point{
					volumePoints[0][j][k],
					volumePoints[0][j][k+1],
					volumePoints[0][j+1][k+1],
					volumePoints[0][j+1][k],
				},
				r.getPixelColor(32*hd+k+2*hd, 8*hd+j),
			))
			r.polygons["helmet"]["left"] = append(r.polygons["helmet"]["left"], NewPolygon(
				[4]*Point{
					volumePoints[8*hd][j][k],
					volumePoints[8*hd][j][k+1],
					volumePoints[8*hd][j+1][k+1],
					volumePoints[8*hd][j+1][k],
				},
				r.getPixelColor(32*hd+(24*hd-1)-k-2*hd, 8*hd+j),
			))
		}
	}

	for i := 0; i < 8*hd; i++ {
		for k := -2 * hd; k < 6*hd; k++ {
			r.polygons["helmet"]["top"] = append(r.polygons["helmet"]["top"], NewPolygon(
				[4]*Point{
					volumePoints[i][0][k],
					volumePoints[i+1][0][k],
					volumePoints[i+1][0][k+1],
					volumePoints[i][0][k+1],
				},
				r.getPixelColor(32*hd+8*hd+i, k+2*hd),
			))
			r.polygons["helmet"]["bottom"] = append(r.polygons["helmet"]["bottom"], NewPolygon(
				[4]*Point{
					volumePoints[i][8*hd][k],
					volumePoints[i+1][8*hd][k],
					volumePoints[i+1][8*hd][k+1],
					volumePoints[i][8*hd][k+1],
				},
				r.getPixelColor(32*hd+16*hd+i, 2*hd+k),
			))
		}
	}
}

// generateTorsoPolygons 生成躯干多边形
func (r *SkinRenderer) generateTorsoPolygons(hd int) {
	volumePoints := make(map[int]map[int]map[int]*Point)

	for i := 0; i <= 8*hd; i++ {
		if volumePoints[i] == nil {
			volumePoints[i] = make(map[int]map[int]*Point)
		}
		for j := 0; j <= 12*hd; j++ {
			if volumePoints[i][j] == nil {
				volumePoints[i][j] = make(map[int]*Point)
			}
			volumePoints[i][j][0] = NewPoint(float64(i), float64(j+8*hd), 0)
			volumePoints[i][j][4*hd] = NewPoint(float64(i), float64(j+8*hd), float64(4*hd))
		}
	}

	for j := 0; j <= 12*hd; j++ {
		if volumePoints[0][j] == nil {
			volumePoints[0][j] = make(map[int]*Point)
		}
		if volumePoints[8*hd][j] == nil {
			volumePoints[8*hd][j] = make(map[int]*Point)
		}
		for k := 0; k <= 4*hd; k++ {
			if volumePoints[0][j][k] == nil {
				volumePoints[0][j][k] = NewPoint(0, float64(j+8*hd), float64(k))
			}
			if volumePoints[8*hd][j][k] == nil {
				volumePoints[8*hd][j][k] = NewPoint(float64(8*hd), float64(j+8*hd), float64(k))
			}
		}
	}

	for i := 0; i <= 8*hd; i++ {
		if volumePoints[i][0] == nil {
			volumePoints[i][0] = make(map[int]*Point)
		}
		if volumePoints[i][12*hd] == nil {
			volumePoints[i][12*hd] = make(map[int]*Point)
		}
		for k := 0; k <= 4*hd; k++ {
			if volumePoints[i][0][k] == nil {
				volumePoints[i][0][k] = NewPoint(float64(i), float64(8*hd), float64(k))
			}
			if volumePoints[i][12*hd][k] == nil {
				volumePoints[i][12*hd][k] = NewPoint(float64(i), float64(12*hd+8*hd), float64(k))
			}
		}
	}

	for i := 0; i < 8*hd; i++ {
		for j := 0; j < 12*hd; j++ {
			r.polygons["torso"]["back"] = append(r.polygons["torso"]["back"], NewPolygon(
				[4]*Point{
					volumePoints[i][j][0],
					volumePoints[i+1][j][0],
					volumePoints[i+1][j+1][0],
					volumePoints[i][j+1][0],
				},
				r.getPixelColor((40*hd-1)-i, 20*hd+j),
			))
			r.polygons["torso"]["front"] = append(r.polygons["torso"]["front"], NewPolygon(
				[4]*Point{
					volumePoints[i][j][4*hd],
					volumePoints[i+1][j][4*hd],
					volumePoints[i+1][j+1][4*hd],
					volumePoints[i][j+1][4*hd],
				},
				r.getPixelColor(20*hd+i, 20*hd+j),
			))
		}
	}

	for j := 0; j < 12*hd; j++ {
		for k := 0; k < 4*hd; k++ {
			r.polygons["torso"]["right"] = append(r.polygons["torso"]["right"], NewPolygon(
				[4]*Point{
					volumePoints[0][j][k],
					volumePoints[0][j][k+1],
					volumePoints[0][j+1][k+1],
					volumePoints[0][j+1][k],
				},
				r.getPixelColor(16*hd+k, 20*hd+j),
			))
			r.polygons["torso"]["left"] = append(r.polygons["torso"]["left"], NewPolygon(
				[4]*Point{
					volumePoints[8*hd][j][k],
					volumePoints[8*hd][j][k+1],
					volumePoints[8*hd][j+1][k+1],
					volumePoints[8*hd][j+1][k],
				},
				r.getPixelColor((32*hd-1)-k, 20*hd+j),
			))
		}
	}

	for i := 0; i < 8*hd; i++ {
		for k := 0; k < 4*hd; k++ {
			r.polygons["torso"]["top"] = append(r.polygons["torso"]["top"], NewPolygon(
				[4]*Point{
					volumePoints[i][0][k],
					volumePoints[i+1][0][k],
					volumePoints[i+1][0][k+1],
					volumePoints[i][0][k+1],
				},
				r.getPixelColor(20*hd+i, 16*hd+k),
			))
			r.polygons["torso"]["bottom"] = append(r.polygons["torso"]["bottom"], NewPolygon(
				[4]*Point{
					volumePoints[i][12*hd][k],
					volumePoints[i+1][12*hd][k],
					volumePoints[i+1][12*hd][k+1],
					volumePoints[i][12*hd][k+1],
				},
				r.getPixelColor(28*hd+i, (20*hd-1)-k),
			))
		}
	}
}

// generateRightArmPolygons 生成右臂多边形
func (r *SkinRenderer) generateRightArmPolygons(hd int) {
	armWidth := 4 * hd
	if r.isAlex {
		armWidth = 3 * hd
	}

	volumePoints := make(map[int]map[int]map[int]*Point)

	for i := 0; i <= armWidth; i++ {
		if volumePoints[i] == nil {
			volumePoints[i] = make(map[int]map[int]*Point)
		}
		for j := 0; j <= 12*hd; j++ {
			if volumePoints[i][j] == nil {
				volumePoints[i][j] = make(map[int]*Point)
			}
			volumePoints[i][j][0] = NewPoint(float64(i-4*hd), float64(j+8*hd), 0)
			volumePoints[i][j][4*hd] = NewPoint(float64(i-4*hd), float64(j+8*hd), float64(4*hd))
		}
	}

	for j := 0; j <= 12*hd; j++ {
		if volumePoints[0][j] == nil {
			volumePoints[0][j] = make(map[int]*Point)
		}
		if volumePoints[armWidth][j] == nil {
			volumePoints[armWidth][j] = make(map[int]*Point)
		}
		for k := 0; k <= 4*hd; k++ {
			if volumePoints[0][j][k] == nil {
				volumePoints[0][j][k] = NewPoint(float64(-4*hd), float64(j+8*hd), float64(k))
			}
			if volumePoints[armWidth][j][k] == nil {
				volumePoints[armWidth][j][k] = NewPoint(float64(armWidth-4*hd), float64(j+8*hd), float64(k))
			}
		}
	}

	for i := 0; i <= armWidth; i++ {
		if volumePoints[i][0] == nil {
			volumePoints[i][0] = make(map[int]*Point)
		}
		if volumePoints[i][12*hd] == nil {
			volumePoints[i][12*hd] = make(map[int]*Point)
		}
		for k := 0; k <= 4*hd; k++ {
			if volumePoints[i][0][k] == nil {
				volumePoints[i][0][k] = NewPoint(float64(i-4*hd), float64(8*hd), float64(k))
			}
			if volumePoints[i][12*hd][k] == nil {
				volumePoints[i][12*hd][k] = NewPoint(float64(i-4*hd), float64(12*hd+8*hd), float64(k))
			}
		}
	}

	// 前后面
	for i := 0; i < armWidth; i++ {
		for j := 0; j < 12*hd; j++ {
			var backX, frontX int
			if r.isAlex {
				backX = (51*hd - 1) - i
				frontX = 44*hd + i
			} else {
				backX = (56*hd - 1) - i
				frontX = 44*hd + i
			}

			r.polygons["rightArm"]["back"] = append(r.polygons["rightArm"]["back"], NewPolygon(
				[4]*Point{
					volumePoints[i][j][0],
					volumePoints[i+1][j][0],
					volumePoints[i+1][j+1][0],
					volumePoints[i][j+1][0],
				},
				r.getPixelColor(backX, 20*hd+j),
			))
			r.polygons["rightArm"]["front"] = append(r.polygons["rightArm"]["front"], NewPolygon(
				[4]*Point{
					volumePoints[i][j][4*hd],
					volumePoints[i+1][j][4*hd],
					volumePoints[i+1][j+1][4*hd],
					volumePoints[i][j+1][4*hd],
				},
				r.getPixelColor(frontX, 20*hd+j),
			))
		}
	}

	// 左右面
	for j := 0; j < 12*hd; j++ {
		for k := 0; k < 4*hd; k++ {
			var rightOffsetX, leftOffsetX int
			if r.isAlex {
				rightOffsetX = 47 * hd
				leftOffsetX = 40 * hd
			} else {
				rightOffsetX = 40 * hd
				leftOffsetX = 52 * hd
			}

			r.polygons["rightArm"]["right"] = append(r.polygons["rightArm"]["right"], NewPolygon(
				[4]*Point{
					volumePoints[0][j][k],
					volumePoints[0][j][k+1],
					volumePoints[0][j+1][k+1],
					volumePoints[0][j+1][k],
				},
				r.getPixelColor(rightOffsetX+k, 20*hd+j),
			))
			r.polygons["rightArm"]["left"] = append(r.polygons["rightArm"]["left"], NewPolygon(
				[4]*Point{
					volumePoints[armWidth][j][k],
					volumePoints[armWidth][j][k+1],
					volumePoints[armWidth][j+1][k+1],
					volumePoints[armWidth][j+1][k],
				},
				r.getPixelColor((leftOffsetX-1)-k, 20*hd+j),
			))
		}
	}

	// 上下面
	for i := 0; i < armWidth; i++ {
		for k := 0; k < 4*hd; k++ {
			var topX, bottomX int
			if r.isAlex {
				topX = 44*hd + i
				bottomX = 47*hd + i
			} else {
				topX = 44*hd + i
				bottomX = 48*hd + i
			}

			r.polygons["rightArm"]["top"] = append(r.polygons["rightArm"]["top"], NewPolygon(
				[4]*Point{
					volumePoints[i][0][k],
					volumePoints[i+1][0][k],
					volumePoints[i+1][0][k+1],
					volumePoints[i][0][k+1],
				},
				r.getPixelColor(topX, 16*hd+k),
			))
			r.polygons["rightArm"]["bottom"] = append(r.polygons["rightArm"]["bottom"], NewPolygon(
				[4]*Point{
					volumePoints[i][12*hd][k],
					volumePoints[i+1][12*hd][k],
					volumePoints[i+1][12*hd][k+1],
					volumePoints[i][12*hd][k+1],
				},
				r.getPixelColor(bottomX, 16*hd+k),
			))
		}
	}
}

// generateLeftArmPolygons 生成左臂多边形
func (r *SkinRenderer) generateLeftArmPolygons(hd int) {
	armWidth := 4 * hd
	if r.isAlex {
		armWidth = 3 * hd
	}

	volumePoints := make(map[int]map[int]map[int]*Point)

	for i := 0; i <= armWidth; i++ {
		if volumePoints[i] == nil {
			volumePoints[i] = make(map[int]map[int]*Point)
		}
		for j := 0; j <= 12*hd; j++ {
			if volumePoints[i][j] == nil {
				volumePoints[i][j] = make(map[int]*Point)
			}
			volumePoints[i][j][0] = NewPoint(float64(i+8*hd), float64(j+8*hd), 0)
			volumePoints[i][j][4*hd] = NewPoint(float64(i+8*hd), float64(j+8*hd), float64(4*hd))
		}
	}

	for j := 0; j <= 12*hd; j++ {
		if volumePoints[0][j] == nil {
			volumePoints[0][j] = make(map[int]*Point)
		}
		if volumePoints[armWidth][j] == nil {
			volumePoints[armWidth][j] = make(map[int]*Point)
		}
		for k := 0; k <= 4*hd; k++ {
			if volumePoints[0][j][k] == nil {
				volumePoints[0][j][k] = NewPoint(float64(8*hd), float64(j+8*hd), float64(k))
			}
			if volumePoints[armWidth][j][k] == nil {
				volumePoints[armWidth][j][k] = NewPoint(float64(armWidth+8*hd), float64(j+8*hd), float64(k))
			}
		}
	}

	for i := 0; i <= armWidth; i++ {
		if volumePoints[i][0] == nil {
			volumePoints[i][0] = make(map[int]*Point)
		}
		if volumePoints[i][12*hd] == nil {
			volumePoints[i][12*hd] = make(map[int]*Point)
		}
		for k := 0; k <= 4*hd; k++ {
			if volumePoints[i][0][k] == nil {
				volumePoints[i][0][k] = NewPoint(float64(i+8*hd), float64(8*hd), float64(k))
			}
			if volumePoints[i][12*hd][k] == nil {
				volumePoints[i][12*hd][k] = NewPoint(float64(i+8*hd), float64(12*hd+8*hd), float64(k))
			}
		}
	}

	// 前后面
	for i := 0; i < armWidth; i++ {
		for j := 0; j < 12*hd; j++ {
			var color1, color2 int

			if r.isAlex {
				color1 = 43*hd + i
				color2 = 36*hd + i
				r.polygons["leftArm"]["back"] = append(r.polygons["leftArm"]["back"], NewPolygon(
					[4]*Point{
						volumePoints[i][j][0],
						volumePoints[i+1][j][0],
						volumePoints[i+1][j+1][0],
						volumePoints[i][j+1][0],
					},
					r.getPixelColor(color1, 52*hd+j),
				))
				r.polygons["leftArm"]["front"] = append(r.polygons["leftArm"]["front"], NewPolygon(
					[4]*Point{
						volumePoints[i][j][4*hd],
						volumePoints[i+1][j][4*hd],
						volumePoints[i+1][j+1][4*hd],
						volumePoints[i][j+1][4*hd],
					},
					r.getPixelColor(color2, 52*hd+j),
				))
			} else {
				if r.isNewSkinType {
					color1 = 47*hd - i // from right to left
					color2 = 36*hd + i // from left to right
					r.polygons["leftArm"]["back"] = append(r.polygons["leftArm"]["back"], NewPolygon(
						[4]*Point{
							volumePoints[i][j][0],
							volumePoints[i+1][j][0],
							volumePoints[i+1][j+1][0],
							volumePoints[i][j+1][0],
						},
						r.getPixelColor(color1, 52*hd+j),
					))
					r.polygons["leftArm"]["front"] = append(r.polygons["leftArm"]["front"], NewPolygon(
						[4]*Point{
							volumePoints[i][j][4*hd],
							volumePoints[i+1][j][4*hd],
							volumePoints[i+1][j+1][4*hd],
							volumePoints[i][j+1][4*hd],
						},
						r.getPixelColor(color2, 52*hd+j),
					))
				} else {
					// 旧版皮肤镜像右臂
					color1 = (56*hd - 1) - ((4*hd - 1) - i)
					color2 = 44*hd + ((4*hd - 1) - i)
					r.polygons["leftArm"]["back"] = append(r.polygons["leftArm"]["back"], NewPolygon(
						[4]*Point{
							volumePoints[i][j][0],
							volumePoints[i+1][j][0],
							volumePoints[i+1][j+1][0],
							volumePoints[i][j+1][0],
						},
						r.getPixelColor(color1, 20*hd+j),
					))
					r.polygons["leftArm"]["front"] = append(r.polygons["leftArm"]["front"], NewPolygon(
						[4]*Point{
							volumePoints[i][j][4*hd],
							volumePoints[i+1][j][4*hd],
							volumePoints[i+1][j+1][4*hd],
							volumePoints[i][j+1][4*hd],
						},
						r.getPixelColor(color2, 20*hd+j),
					))
				}
			}
		}
	}

	// 左右面
	for j := 0; j < 12*hd; j++ {
		for k := 0; k < 4*hd; k++ {
			var color1X, color2X, color1Y, color2Y int

			if r.isNewSkinType {
				color1X = 32*hd + k
				color2X = 43*hd - k
				color1Y = 52*hd + j
				color2Y = 52*hd + j
			} else {
				color1X = 40*hd + ((4*hd - 1) - k)
				color2X = (52*hd - 1) - ((4*hd - 1) - k)
				color1Y = 20*hd + j
				color2Y = 20*hd + j
			}

			r.polygons["leftArm"]["right"] = append(r.polygons["leftArm"]["right"], NewPolygon(
				[4]*Point{
					volumePoints[0][j][k],
					volumePoints[0][j][k+1],
					volumePoints[0][j+1][k+1],
					volumePoints[0][j+1][k],
				},
				r.getPixelColor(color1X, color1Y),
			))
			r.polygons["leftArm"]["left"] = append(r.polygons["leftArm"]["left"], NewPolygon(
				[4]*Point{
					volumePoints[armWidth][j][k],
					volumePoints[armWidth][j][k+1],
					volumePoints[armWidth][j+1][k+1],
					volumePoints[armWidth][j+1][k],
				},
				r.getPixelColor(color2X, color2Y),
			))
		}
	}

	// 上下面
	for i := 0; i < armWidth; i++ {
		for k := 0; k < 4*hd; k++ {
			var topX, topY, bottomX, bottomY int

			if r.isAlex {
				topX = 36*hd + i
				topY = 48*hd + k
				bottomX = 39*hd + i
				bottomY = 48*hd + k
			} else if r.isNewSkinType {
				topX = 36*hd + i
				topY = 48*hd + k
				bottomX = 40*hd + i
				bottomY = 48*hd + k
			} else {
				topX = 44*hd + ((4*hd - 1) - i)
				topY = 16*hd + k
				bottomX = 48*hd + ((4*hd - 1) - i)
				bottomY = (20*hd - 1) - k
			}

			r.polygons["leftArm"]["top"] = append(r.polygons["leftArm"]["top"], NewPolygon(
				[4]*Point{
					volumePoints[i][0][k],
					volumePoints[i+1][0][k],
					volumePoints[i+1][0][k+1],
					volumePoints[i][0][k+1],
				},
				r.getPixelColor(topX, topY),
			))
			r.polygons["leftArm"]["bottom"] = append(r.polygons["leftArm"]["bottom"], NewPolygon(
				[4]*Point{
					volumePoints[i][12*hd][k],
					volumePoints[i+1][12*hd][k],
					volumePoints[i+1][12*hd][k+1],
					volumePoints[i][12*hd][k+1],
				},
				r.getPixelColor(bottomX, bottomY),
			))
		}
	}
}

// generateRightLegPolygons 生成右腿多边形
func (r *SkinRenderer) generateRightLegPolygons(hd int) {
	volumePoints := make(map[int]map[int]map[int]*Point)

	for i := 0; i <= 4*hd; i++ {
		if volumePoints[i] == nil {
			volumePoints[i] = make(map[int]map[int]*Point)
		}
		for j := 0; j <= 12*hd; j++ {
			if volumePoints[i][j] == nil {
				volumePoints[i][j] = make(map[int]*Point)
			}
			volumePoints[i][j][0] = NewPoint(float64(i), float64(j+20*hd), 0)
			volumePoints[i][j][4*hd] = NewPoint(float64(i), float64(j+20*hd), float64(4*hd))
		}
	}

	for j := 0; j <= 12*hd; j++ {
		if volumePoints[0][j] == nil {
			volumePoints[0][j] = make(map[int]*Point)
		}
		if volumePoints[4*hd][j] == nil {
			volumePoints[4*hd][j] = make(map[int]*Point)
		}
		for k := 0; k <= 4*hd; k++ {
			if volumePoints[0][j][k] == nil {
				volumePoints[0][j][k] = NewPoint(0, float64(j+20*hd), float64(k))
			}
			if volumePoints[4*hd][j][k] == nil {
				volumePoints[4*hd][j][k] = NewPoint(float64(4*hd), float64(j+20*hd), float64(k))
			}
		}
	}

	for i := 0; i <= 4*hd; i++ {
		if volumePoints[i][0] == nil {
			volumePoints[i][0] = make(map[int]*Point)
		}
		if volumePoints[i][12*hd] == nil {
			volumePoints[i][12*hd] = make(map[int]*Point)
		}
		for k := 0; k <= 4*hd; k++ {
			if volumePoints[i][0][k] == nil {
				volumePoints[i][0][k] = NewPoint(float64(i), float64(20*hd), float64(k))
			}
			if volumePoints[i][12*hd][k] == nil {
				volumePoints[i][12*hd][k] = NewPoint(float64(i), float64(12*hd+20*hd), float64(k))
			}
		}
	}

	for i := 0; i < 4*hd; i++ {
		for j := 0; j < 12*hd; j++ {
			r.polygons["rightLeg"]["back"] = append(r.polygons["rightLeg"]["back"], NewPolygon(
				[4]*Point{
					volumePoints[i][j][0],
					volumePoints[i+1][j][0],
					volumePoints[i+1][j+1][0],
					volumePoints[i][j+1][0],
				},
				r.getPixelColor((16*hd-1)-i, 20*hd+j),
			))
			r.polygons["rightLeg"]["front"] = append(r.polygons["rightLeg"]["front"], NewPolygon(
				[4]*Point{
					volumePoints[i][j][4*hd],
					volumePoints[i+1][j][4*hd],
					volumePoints[i+1][j+1][4*hd],
					volumePoints[i][j+1][4*hd],
				},
				r.getPixelColor(4*hd+i, 20*hd+j),
			))
		}
	}

	for j := 0; j < 12*hd; j++ {
		for k := 0; k < 4*hd; k++ {
			r.polygons["rightLeg"]["right"] = append(r.polygons["rightLeg"]["right"], NewPolygon(
				[4]*Point{
					volumePoints[0][j][k],
					volumePoints[0][j][k+1],
					volumePoints[0][j+1][k+1],
					volumePoints[0][j+1][k],
				},
				r.getPixelColor(k, 20*hd+j),
			))
			r.polygons["rightLeg"]["left"] = append(r.polygons["rightLeg"]["left"], NewPolygon(
				[4]*Point{
					volumePoints[4*hd][j][k],
					volumePoints[4*hd][j][k+1],
					volumePoints[4*hd][j+1][k+1],
					volumePoints[4*hd][j+1][k],
				},
				r.getPixelColor((12*hd-1)-k, 20*hd+j),
			))
		}
	}

	for i := 0; i < 4*hd; i++ {
		for k := 0; k < 4*hd; k++ {
			r.polygons["rightLeg"]["top"] = append(r.polygons["rightLeg"]["top"], NewPolygon(
				[4]*Point{
					volumePoints[i][0][k],
					volumePoints[i+1][0][k],
					volumePoints[i+1][0][k+1],
					volumePoints[i][0][k+1],
				},
				r.getPixelColor(4*hd+i, 16*hd+k),
			))
			r.polygons["rightLeg"]["bottom"] = append(r.polygons["rightLeg"]["bottom"], NewPolygon(
				[4]*Point{
					volumePoints[i][12*hd][k],
					volumePoints[i+1][12*hd][k],
					volumePoints[i+1][12*hd][k+1],
					volumePoints[i][12*hd][k+1],
				},
				r.getPixelColor(8*hd+i, 16*hd+k),
			))
		}
	}
}

// generateLeftLegPolygons 生成左腿多边形
func (r *SkinRenderer) generateLeftLegPolygons(hd int) {
	volumePoints := make(map[int]map[int]map[int]*Point)

	for i := 0; i <= 4*hd; i++ {
		if volumePoints[i] == nil {
			volumePoints[i] = make(map[int]map[int]*Point)
		}
		for j := 0; j <= 12*hd; j++ {
			if volumePoints[i][j] == nil {
				volumePoints[i][j] = make(map[int]*Point)
			}
			volumePoints[i][j][0] = NewPoint(float64(i+4*hd), float64(j+20*hd), 0)
			volumePoints[i][j][4*hd] = NewPoint(float64(i+4*hd), float64(j+20*hd), float64(4*hd))
		}
	}

	for j := 0; j <= 12*hd; j++ {
		if volumePoints[0][j] == nil {
			volumePoints[0][j] = make(map[int]*Point)
		}
		if volumePoints[4*hd][j] == nil {
			volumePoints[4*hd][j] = make(map[int]*Point)
		}
		for k := 0; k <= 4*hd; k++ {
			if volumePoints[0][j][k] == nil {
				volumePoints[0][j][k] = NewPoint(float64(4*hd), float64(j+20*hd), float64(k))
			}
			if volumePoints[4*hd][j][k] == nil {
				volumePoints[4*hd][j][k] = NewPoint(float64(4*hd+4*hd), float64(j+20*hd), float64(k))
			}
		}
	}

	for i := 0; i <= 4*hd; i++ {
		if volumePoints[i][0] == nil {
			volumePoints[i][0] = make(map[int]*Point)
		}
		if volumePoints[i][12*hd] == nil {
			volumePoints[i][12*hd] = make(map[int]*Point)
		}
		for k := 0; k <= 4*hd; k++ {
			if volumePoints[i][0][k] == nil {
				volumePoints[i][0][k] = NewPoint(float64(i+4*hd), float64(20*hd), float64(k))
			}
			if volumePoints[i][12*hd][k] == nil {
				volumePoints[i][12*hd][k] = NewPoint(float64(i+4*hd), float64(12*hd+20*hd), float64(k))
			}
		}
	}

	for i := 0; i < 4*hd; i++ {
		for j := 0; j < 12*hd; j++ {
			var color1X, color2X, color1Y, color2Y int

			if r.isNewSkinType {
				color1X = 31*hd - i // from right to left
				color2X = 20*hd + i // from left to right
				color1Y = 52*hd + j
				color2Y = 52*hd + j
			} else {
				color1X = (16*hd - 1) - ((4*hd - 1) - i)
				color2X = 4*hd + ((4*hd - 1) - i)
				color1Y = 20*hd + j
				color2Y = 20*hd + j
			}

			r.polygons["leftLeg"]["back"] = append(r.polygons["leftLeg"]["back"], NewPolygon(
				[4]*Point{
					volumePoints[i][j][0],
					volumePoints[i+1][j][0],
					volumePoints[i+1][j+1][0],
					volumePoints[i][j+1][0],
				},
				r.getPixelColor(color1X, color1Y),
			))
			r.polygons["leftLeg"]["front"] = append(r.polygons["leftLeg"]["front"], NewPolygon(
				[4]*Point{
					volumePoints[i][j][4*hd],
					volumePoints[i+1][j][4*hd],
					volumePoints[i+1][j+1][4*hd],
					volumePoints[i][j+1][4*hd],
				},
				r.getPixelColor(color2X, color2Y),
			))
		}
	}

	for j := 0; j < 12*hd; j++ {
		for k := 0; k < 4*hd; k++ {
			var color1X, color2X, color1Y, color2Y int

			if r.isNewSkinType {
				color1X = 16*hd + k // from left to right
				color2X = 27*hd - k // from right to left
				color1Y = 52*hd + j
				color2Y = 52*hd + j
			} else {
				color1X = ((4*hd - 1) - k)
				color2X = (12*hd - 1) - ((4*hd - 1) - k)
				color1Y = 20*hd + j
				color2Y = 20*hd + j
			}

			r.polygons["leftLeg"]["right"] = append(r.polygons["leftLeg"]["right"], NewPolygon(
				[4]*Point{
					volumePoints[0][j][k],
					volumePoints[0][j][k+1],
					volumePoints[0][j+1][k+1],
					volumePoints[0][j+1][k],
				},
				r.getPixelColor(color1X, color1Y),
			))
			r.polygons["leftLeg"]["left"] = append(r.polygons["leftLeg"]["left"], NewPolygon(
				[4]*Point{
					volumePoints[4*hd][j][k],
					volumePoints[4*hd][j][k+1],
					volumePoints[4*hd][j+1][k+1],
					volumePoints[4*hd][j+1][k],
				},
				r.getPixelColor(color2X, color2Y),
			))
		}
	}

	for i := 0; i < 4*hd; i++ {
		for k := 0; k < 4*hd; k++ {
			var topX, topY, bottomX, bottomY int

			if r.isNewSkinType {
				topX = 20*hd + i
				topY = 48*hd + k
				bottomX = 24*hd + i
				bottomY = 48*hd + k
			} else {
				topX = 4*hd + ((4*hd - 1) - i)
				topY = 16*hd + k
				bottomX = 8*hd + ((4*hd - 1) - i)
				bottomY = (20*hd - 1) - k
			}

			r.polygons["leftLeg"]["top"] = append(r.polygons["leftLeg"]["top"], NewPolygon(
				[4]*Point{
					volumePoints[i][0][k],
					volumePoints[i+1][0][k],
					volumePoints[i+1][0][k+1],
					volumePoints[i][0][k+1],
				},
				r.getPixelColor(topX, topY),
			))
			r.polygons["leftLeg"]["bottom"] = append(r.polygons["leftLeg"]["bottom"], NewPolygon(
				[4]*Point{
					volumePoints[i][12*hd][k],
					volumePoints[i+1][12*hd][k],
					volumePoints[i+1][12*hd][k+1],
					volumePoints[i][12*hd][k+1],
				},
				r.getPixelColor(bottomX, bottomY),
			))
		}
	}
}