1081 lines
29 KiB
Go
1081 lines
29 KiB
Go
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),
|
||
))
|
||
}
|
||
}
|
||
}
|