Implement support for custom blocks

cmd/blockhash/main.go

@@ -55,12 +55,13 @@ func procPackage(pkg *ast.Package, fs *token.FileSet, w io.Writer) {
 
 	b.writePackage(w)
 	i := b.writeConstants(w)
+	b.writeNextHash(w)
 	b.writeMethods(w, i)
 }
 
 var (
 	packageFormat = "// Code generated by cmd/blockhash; DO NOT EDIT.\n\npackage %v\n\n"
-	methodFormat  = "\nfunc (%v%v) Hash() uint64 {\n\treturn %v\n}\n"
+	methodFormat  = "\n// Hash ...\nfunc (%v%v) Hash() uint64 {\n\treturn %v\n}\n"
 	constFormat   = "\thash%v"
 )
 
@@ -112,13 +113,28 @@ func (b *hashBuilder) writeConstants(w io.Writer) (bitSize int) {
 		i++
 	}
 
-	if _, err := fmt.Fprintln(w, ")"); err != nil {
+	if _, err := fmt.Fprintln(w, "\thashBase\n)"); err != nil {
 		log.Fatalln(err)
 	}
 
 	return bits.Len64(i)
 }
 
+func (b *hashBuilder) writeNextHash(w io.Writer) {
+	if _, err := fmt.Fprintln(w, "\n// base represents the base hash for all custom blocks."); err != nil {
+		log.Fatalln(err)
+	}
+	if _, err := fmt.Fprintln(w, "var base = uint64(hashBase - 1)"); err != nil {
+		log.Fatalln(err)
+	}
+	if _, err := fmt.Fprintln(w, "\n// NextHash returns the next free hash for custom blocks."); err != nil {
+		log.Fatalln(err)
+	}
+	if _, err := fmt.Fprintln(w, "func NextHash() uint64 {\n\tbase++\n\treturn base\n}"); err != nil {
+		log.Fatalln(err)
+	}
+}
+
 func (b *hashBuilder) writeMethods(w io.Writer, baseBits int) {
 	for _, name := range b.names {
 		fields := b.blockFields[name]

main.go

@@ -3,7 +3,12 @@ package main
 import (
 	"fmt"
 	"github.com/df-mc/dragonfly/server"
+	"github.com/df-mc/dragonfly/server/block"
+	"github.com/df-mc/dragonfly/server/item"
+	"github.com/df-mc/dragonfly/server/item/creative"
+	"github.com/df-mc/dragonfly/server/player"
 	"github.com/df-mc/dragonfly/server/player/chat"
+	"github.com/df-mc/dragonfly/server/world"
 	"github.com/pelletier/go-toml"
 	"github.com/sirupsen/logrus"
 	"io/ioutil"
@@ -22,13 +27,19 @@ func main() {
 		log.Fatalln(err)
 	}
 
+	world.RegisterBlock(block.PHP{})
+	world.RegisterItem(block.PHP{})
+	creative.RegisterItem(item.NewStack(block.PHP{}, 64))
+
 	srv := server.New(&config, log)
 	srv.CloseOnProgramEnd()
 	if err := srv.Start(); err != nil {
 		log.Fatalln(err)
 	}
 
-	for srv.Accept(nil) {
+	for srv.Accept(func(p *player.Player) {
+		p.Inventory().AddItem(item.NewStack(block.PHP{}, 32))
+	}) {
 	}
 }
 

php.geo.json

@@ -0,0 +1,47 @@
+{
+  "format_version": "1.12.0",
+  "minecraft:geometry": [
+    {
+      "description": {
+        "identifier": "geometry.php.cube",
+        "texture_width": 64,
+        "texture_height": 64,
+        "visible_bounds_width": 2,
+        "visible_bounds_height": 2.5,
+        "visible_bounds_offset": [
+          0,
+          0.75,
+          0
+        ]
+      },
+      "bones": [
+        {
+          "name": "bb_main",
+          "pivot": [
+            0,
+            0,
+            0
+          ],
+          "cubes": [
+            {
+              "origin": [
+                -8,
+                0,
+                -8
+              ],
+              "size": [
+                16,
+                16,
+                16
+              ],
+              "uv": [
+                0,
+                0
+              ]
+            }
+          ]
+        }
+      ]
+    }
+  ]
+}

server/block/customblock/geometry.go

@@ -0,0 +1,62 @@
+package customblock
+
+import (
+	"github.com/go-gl/mathgl/mgl64"
+	"math"
+)
+
+// Geometries represents the JSON structure of a vanilla geometry file. It contains a format version and a slice of
+// unique geometries.
+type Geometries struct {
+	FormatVersion string     `json:"format_version"`
+	Geometry      []Geometry `json:"minecraft:geometry"`
+}
+
+// Geometry represents a single geometry that contains bones and other information.
+type Geometry struct {
+	Description struct {
+		Identifier          string     `json:"identifier"`
+		TextureWidth        int        `json:"texture_width"`
+		TextureHeight       int        `json:"texture_height"`
+		VisibleBoundsWidth  float64    `json:"visible_bounds_width"`
+		VisibleBoundsHeight float64    `json:"visible_bounds_height"`
+		VisibleBoundsOffset mgl64.Vec3 `json:"visible_bounds_offset"`
+	} `json:"description"`
+	Bones []struct {
+		Name     string     `json:"name"`
+		Pivot    mgl64.Vec3 `json:"pivot,omitempty"`
+		Rotation mgl64.Vec3 `json:"rotation,omitempty"`
+		Cubes    []struct {
+			Origin   mgl64.Vec3 `json:"origin"`
+			Size     mgl64.Vec3 `json:"size"`
+			UV       mgl64.Vec2 `json:"uv"`
+			Pivot    mgl64.Vec3 `json:"pivot,omitempty"`
+			Rotation mgl64.Vec3 `json:"rotation,omitempty"`
+			Inflate  float64    `json:"inflate,omitempty"`
+		} `json:"cubes"`
+	} `json:"bones"`
+}
+
+// Origin returns the origin of the geometry. It is calculated by using the smallest origin points of all cubes.
+func (g Geometry) Origin() (x mgl64.Vec3) {
+	for _, bone := range g.Bones {
+		for _, cube := range bone.Cubes {
+			x[0] = math.Min(x[0], cube.Origin.X())
+			x[1] = math.Min(x[1], cube.Origin.Y())
+			x[2] = math.Min(x[2], cube.Origin.Z())
+		}
+	}
+	return
+}
+
+// Size returns the size of the geometry. It is calculated by using the largest size of all cubes.
+func (g Geometry) Size() (x mgl64.Vec3) {
+	for _, bone := range g.Bones {
+		for _, cube := range bone.Cubes {
+			x[0] = math.Max(x[0], cube.Size.X())
+			x[1] = math.Max(x[1], cube.Size.Y())
+			x[2] = math.Max(x[2], cube.Size.Z())
+		}
+	}
+	return
+}

server/block/customblock/material.go

@@ -0,0 +1,66 @@
+package customblock
+
+// Material represents a single material used for rendering part of a custom block.
+type Material struct {
+	// texture is the name of the texture for the material.
+	texture string
+	// renderMethod is the method to use when rendering the material.
+	renderMethod RenderMethod
+	// faceDimming is if the material should be dimmed by the direction it's facing.
+	faceDimming bool
+	// ambientOcclusion is if the material should have ambient occlusion applied when lighting.
+	ambientOcclusion bool
+}
+
+// NewMaterial returns a new Material with the provided information. It also enabled face dimming and ambient occlusion
+// by default based on the render method.
+func NewMaterial(texture string, method RenderMethod) Material {
+	return Material{
+		faceDimming:      true,
+		texture:          texture,
+		renderMethod:     method,
+		ambientOcclusion: method.AmbientOcclusion(),
+	}
+}
+
+// WithFaceDimming returns a copy of the Material with face dimming enabled.
+func (m Material) WithFaceDimming() Material {
+	m.faceDimming = true
+	return m
+}
+
+// WithoutFaceDimming returns a copy of the Material with face dimming disabled.
+func (m Material) WithoutFaceDimming() Material {
+	m.faceDimming = false
+	return m
+}
+
+// WithAmbientOcclusion returns a copy of the Material with ambient occlusion enabled.
+func (m Material) WithAmbientOcclusion() Material {
+	m.ambientOcclusion = true
+	return m
+}
+
+// WithoutAmbientOcclusion returns a copy of the Material with ambient occlusion disabled.
+func (m Material) WithoutAmbientOcclusion() Material {
+	m.ambientOcclusion = false
+	return m
+}
+
+// Encode returns the material encoded as a map[string]any.
+func (m Material) Encode() map[string]any {
+	return map[string]any{
+		"texture":           m.texture,
+		"render_method":     m.renderMethod.String(),
+		"face_dimming":      boolByte(m.faceDimming),
+		"ambient_occlusion": boolByte(m.ambientOcclusion),
+	}
+}
+
+// boolByte returns 1 if the bool passed is true, or 0 if it is false.
+func boolByte(b bool) uint8 {
+	if b {
+		return 1
+	}
+	return 0
+}

server/block/customblock/material_target.go

@@ -0,0 +1,59 @@
+package customblock
+
+// MaterialTarget represents a material target for a custom block. These are limited to either all targets, or the top,
+// bottom, and sides.
+type MaterialTarget struct {
+	materialTarget
+}
+
+// MaterialTargetAll represents the material target for all targets.
+func MaterialTargetAll() MaterialTarget {
+	return MaterialTarget{0}
+}
+
+// MaterialTargetUp represents the material target for the top of the block.
+func MaterialTargetUp() MaterialTarget {
+	return MaterialTarget{1}
+}
+
+// MaterialTargetDown represents the material target for the bottom of the block.
+func MaterialTargetDown() MaterialTarget {
+	return MaterialTarget{2}
+}
+
+// MaterialTargetSides represents the material target for the sides of the block.
+func MaterialTargetSides() MaterialTarget {
+	return MaterialTarget{3}
+}
+
+type materialTarget uint8
+
+// Name returns the name of the material target.
+func (m materialTarget) Name() string {
+	switch m {
+	case 0:
+		return "all"
+	case 1:
+		return "up"
+	case 2:
+		return "down"
+	case 3:
+		return "sides"
+	}
+	panic("should never happen")
+}
+
+// String returns the string representation of the material target.
+func (m materialTarget) String() string {
+	switch m {
+	case 0:
+		return "*"
+	case 1:
+		return "up"
+	case 2:
+		return "down"
+	case 3:
+		return "sides"
+	}
+	panic("should never happen")
+}

server/block/customblock/model.go

@@ -0,0 +1,66 @@
+package customblock
+
+import (
+	"fmt"
+	"github.com/go-gl/mathgl/mgl32"
+	"github.com/go-gl/mathgl/mgl64"
+	"golang.org/x/exp/maps"
+)
+
+// Model represents the model of a custom block. It can contain multiple materials applied to different parts of the
+// model, as well as a reference to its geometry.
+type Model struct {
+	materials    map[string]Material
+	geometryName string
+	origin       mgl64.Vec3
+	size         mgl64.Vec3
+}
+
+// NewModel returns a new Model with the provided information. If the size is larger than 16x16x16, this method will
+// panic since the client does not allow models larger than a single block.
+func NewModel(geometryName string, origin, size mgl64.Vec3) Model {
+	if size.X() > 16 || size.Y() > 16 || size.Z() > 16 {
+		panic(fmt.Errorf("model size cannot exceed 16x16x16, got %v", size))
+	}
+	return Model{
+		geometryName: geometryName,
+		origin:       origin,
+		size:         size,
+	}
+}
+
+// WithMaterial returns a copy of the Model with the provided material.
+func (m Model) WithMaterial(target string, material Material) Model {
+	m.materials = maps.Clone(m.materials)
+	m.materials[target] = material
+	return m
+}
+
+// Encode returns the model encoded as a map[string]any.
+func (m Model) Encode() map[string]any {
+	materials := map[string]any{}
+	for target, material := range m.materials {
+		materials[target] = material.Encode()
+	}
+	origin := vec64To32(m.origin)
+	size := vec64To32(m.size)
+	return map[string]any{
+		"minecraft:material_instances": map[string]any{
+			"mappings":  map[string]any{},
+			"materials": materials,
+		},
+		"minecraft:geometry": map[string]any{
+			"value": m.geometryName,
+		},
+		"minecraft:pick_collision": map[string]any{
+			"enabled": uint8(1),
+			"origin":  origin[:],
+			"size":    size[:],
+		},
+	}
+}
+
+// vec64To32 converts a mgl64.Vec3 to a mgl32.Vec3.
+func vec64To32(vec3 mgl64.Vec3) mgl32.Vec3 {
+	return mgl32.Vec3{float32(vec3[0]), float32(vec3[1]), float32(vec3[2])}
+}