Files
backend/internal/service/skin_renderer/polygons.go

1081 lines
29 KiB
Go
Raw Normal View History

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),
))
}
}
}