It's alive! It's bad, but it's alive!

Author: ClickerMonkey

README.md

@@ -1,6 +1,9 @@
 # axe-go
 Axe Game Engine for Go
 
+### Todo
+- [ ] OBJ loader
+
 ### Use
 - Load preferences
 - Initialize systems (audio, graphics, input, window)

go.mod

@@ -9,3 +9,5 @@ require (
 )
 
 require github.com/go-gl/gl v0.0.0-20211210172815-726fda9656d6
+
+require github.com/udhos/gwob v0.0.0-20200524213453-619810f75817 // indirect

go.sum

@@ -4,5 +4,7 @@ github.com/go-gl/glfw/v3.3/glfw v0.0.0-20221017161538-93cebf72946b h1:GgabKamyOY
 github.com/go-gl/glfw/v3.3/glfw v0.0.0-20221017161538-93cebf72946b/go.mod h1:tQ2UAYgL5IevRw8kRxooKSPJfGvJ9fJQFa0TUsXzTg8=
 github.com/sparkkoori/go-vulkan v0.0.0-20190815142752-7cafa944f8f2 h1:X/+cw8BWv95cDwT/ON5IWYSaatQfdCEBI1hKfApLOUg=
 github.com/sparkkoori/go-vulkan v0.0.0-20190815142752-7cafa944f8f2/go.mod h1:dFKNCFrbk5+XCiRYZAPBFRmV++R/OJ93a8Jdg0gzErw=
+github.com/udhos/gwob v0.0.0-20200524213453-619810f75817 h1:4M105Yb9NHJ/sI3xAS3WbXt4d09q940504X5zE5JM7s=
+github.com/udhos/gwob v0.0.0-20200524213453-619810f75817/go.mod h1:kOhibXY50yGPKNcoFg+KDoC4hGzyJ6YX0wfKHhThntk=
 golang.org/x/exp v0.0.0-20221031165847-c99f073a8326 h1:QfTh0HpN6hlw6D3vu8DAwC8pBIwikq0AI1evdm+FksE=
 golang.org/x/exp v0.0.0-20221031165847-c99f073a8326/go.mod h1:CxIveKay+FTh1D0yPZemJVgC/95VzuuOLq5Qi4xnoYc=

pkg/asset-json.go

@@ -6,7 +6,7 @@ import (
 	"regexp"
 )
 
-type JsonGenericAssetLoader struct{}
+type JsonGenericAssetFormat struct{}
 type JsonValueKind int
 
 const (
@@ -28,18 +28,18 @@ type JsonValue struct {
 	Parent *JsonValue
 }
 
-var _ AssetFormat = &JsonGenericAssetLoader{}
-var jsonGenericAssetLoaderRegex, _ = regexp.Compile(`\.json$`)
+var _ AssetFormat = &JsonGenericAssetFormat{}
+var jsonGenericAssetFormatRegex, _ = regexp.Compile(`\.json$`)
 
-func (loader *JsonGenericAssetLoader) Handles(ref AssetRef) bool {
-	return jsonGenericAssetLoaderRegex.MatchString(ref.URI)
+func (format *JsonGenericAssetFormat) Handles(ref AssetRef) bool {
+	return jsonGenericAssetFormatRegex.MatchString(ref.URI)
 }
 
-func (loader *JsonGenericAssetLoader) Types() []AssetType {
+func (format *JsonGenericAssetFormat) Types() []AssetType {
 	return []AssetType{AssetTypeJson}
 }
 
-func (loader *JsonGenericAssetLoader) Load(asset *Asset) error {
+func (format *JsonGenericAssetFormat) Load(asset *Asset) error {
 	decoder := json.NewDecoder(asset.SourceReader)
 
 	var setValue func(out *JsonValue) error
@@ -136,15 +136,15 @@ func (loader *JsonGenericAssetLoader) Load(asset *Asset) error {
 
 	return err
 }
-func (loader *JsonGenericAssetLoader) Unload(asset *Asset) error {
+func (format *JsonGenericAssetFormat) Unload(asset *Asset) error {
 	asset.LoadStatus.Reset()
 	return nil
 }
-func (loader *JsonGenericAssetLoader) Activate(asset *Asset) error {
+func (format *JsonGenericAssetFormat) Activate(asset *Asset) error {
 	asset.ActivateStatus.Success()
 	return nil
 }
-func (loader *JsonGenericAssetLoader) Deactivate(asset *Asset) error {
+func (format *JsonGenericAssetFormat) Deactivate(asset *Asset) error {
 	asset.ActivateStatus.Reset()
 	return nil
 }

pkg/asset-mtl.go

@@ -0,0 +1,95 @@
+package axe
+
+import (
+	"regexp"
+
+	"github.com/udhos/gwob"
+)
+
+var _ AssetFormat = &MtlFormat{}
+var mtlFormatRegex, _ = regexp.Compile(`\.mtl$`)
+
+type MtlFormat struct {
+}
+
+func (format *MtlFormat) Handles(ref AssetRef) bool {
+	return mtlFormatRegex.MatchString(ref.URI)
+}
+
+func (format *MtlFormat) Types() []AssetType {
+	return []AssetType{AssetTypeModel}
+}
+
+func (format *MtlFormat) Load(asset *Asset) error {
+	lib, err := gwob.ReadMaterialLibFromReader(asset.SourceReader, &gwob.ObjParserOptions{})
+
+	if err != nil {
+		asset.LoadStatus.Fail(err)
+		return err
+	}
+
+	materials := Materials{}
+	asset.Dependent = make([]AssetRef, 0)
+
+	for materialName, material := range lib.Lib {
+		mat := Material{
+			Name:       material.Name,
+			Illum:      material.Illum,
+			Opacity:    material.D,
+			Refraction: material.Ni,
+			Shininess:  material.Ns,
+			Ambient: TextureColor{
+				Texture: material.MapKa,
+				Color:   material.Ka,
+			},
+			Diffuse: TextureColor{
+				Texture: material.MapKd,
+				Color:   material.Kd,
+			},
+			Specular: TextureColor{
+				Texture: material.MapKs,
+				Color:   material.Ks,
+			},
+			Emissive: TextureColor{
+				Texture: material.MapKe,
+			},
+			TextureBump: material.Bump,
+		}
+
+		if mat.Ambient.Texture != "" {
+			asset.AddNext(mat.Ambient.Texture, true)
+		}
+		if mat.Specular.Texture != "" {
+			asset.AddNext(mat.Specular.Texture, true)
+		}
+		if mat.Diffuse.Texture != "" {
+			asset.AddNext(mat.Diffuse.Texture, true)
+		}
+		if mat.Emissive.Texture != "" {
+			asset.AddNext(mat.Emissive.Texture, true)
+		}
+		if mat.TextureBump != "" {
+			asset.AddNext(mat.TextureBump, true)
+		}
+
+		materials[materialName] = mat
+	}
+
+	asset.Data = materials
+	asset.LoadStatus.Success()
+
+	return nil
+}
+
+func (format *MtlFormat) Unload(asset *Asset) error {
+	asset.LoadStatus.Reset()
+	return nil
+}
+func (format *MtlFormat) Activate(asset *Asset) error {
+	asset.ActivateStatus.Success()
+	return nil
+}
+func (format *MtlFormat) Deactivate(asset *Asset) error {
+	asset.ActivateStatus.Reset()
+	return nil
+}

pkg/asset-obj.go

@@ -0,0 +1,130 @@
+package axe
+
+import (
+	"regexp"
+
+	"github.com/udhos/gwob"
+)
+
+var _ AssetFormat = &ObjFormat{}
+var objFormatRegex, _ = regexp.Compile(`\.obj$`)
+
+type ObjFormat struct {
+}
+
+func (format *ObjFormat) Handles(ref AssetRef) bool {
+	return objFormatRegex.MatchString(ref.URI)
+}
+
+func (format *ObjFormat) Types() []AssetType {
+	return []AssetType{AssetTypeModel}
+}
+
+func (format *ObjFormat) Load(asset *Asset) error {
+	obj, err := gwob.NewObjFromReader(asset.Ref.Name, asset.SourceReader, nil)
+	if err != nil {
+		asset.LoadStatus.Fail(err)
+		return err
+	}
+
+	strideElements := obj.StrideSize >> 2
+	offsetVertex := obj.StrideOffsetPosition >> 2
+	offsetNormal := obj.StrideOffsetNormal >> 2
+	offsetTexCoord := obj.StrideOffsetTexture >> 2
+
+	countVertex := obj.NumberOfElements()
+	countNormals := 0
+	if obj.NormCoordFound {
+		countNormals = countVertex
+	}
+	countTexCoords := 0
+	if obj.TextCoordFound {
+		countTexCoords = countVertex
+	}
+
+	mesh := MeshData{
+		Name:      asset.Ref.Name,
+		Vertices:  make([][3]float32, countVertex),
+		Normals:   make([][3]float32, countNormals),
+		Uvs:       make([][2]float32, countTexCoords),
+		Groups:    make([]MeshFaceGroup, len(obj.Groups)),
+		Materials: obj.Mtllib,
+	}
+
+	for i := range mesh.Vertices {
+		off := i * strideElements
+		offVertex := off + offsetVertex
+
+		mesh.Vertices[i] = [3]float32{
+			obj.Coord[offVertex+0],
+			obj.Coord[offVertex+1],
+			obj.Coord[offVertex+2],
+		}
+
+		if obj.NormCoordFound {
+			offNormal := off + offsetNormal
+
+			mesh.Normals[i] = [3]float32{
+				obj.Coord[offNormal+0],
+				obj.Coord[offNormal+1],
+				obj.Coord[offNormal+2],
+			}
+		}
+
+		if obj.TextCoordFound {
+			offTexCoord := off + offsetTexCoord
+
+			mesh.Uvs[i] = [2]float32{
+				obj.Coord[offTexCoord+0],
+				obj.Coord[offTexCoord+1],
+			}
+		}
+	}
+
+	for _, group := range obj.Groups {
+		meshGroup := MeshFaceGroup{
+			Material: group.Usemtl,
+			Faces:    make([]Face, 0),
+		}
+
+		s := group.IndexBegin
+		e := s + group.IndexCount
+		for i := s; i < e; i += 3 {
+			a := obj.Indices[i]
+			b := obj.Indices[i+1]
+			c := obj.Indices[i+2]
+
+			face := Face{
+				Vertices: []int{a, b, c},
+			}
+			if obj.NormCoordFound {
+				face.Normals = []int{a, b, c}
+			}
+			if obj.TextCoordFound {
+				face.Uvs = []int{a, b, c}
+			}
+
+			meshGroup.Faces = append(meshGroup.Faces, face)
+		}
+		mesh.Groups = append(mesh.Groups, meshGroup)
+	}
+
+	asset.Data = mesh
+	asset.LoadStatus.Success()
+	asset.AddNext(obj.Mtllib, true)
+
+	return nil
+}
+
+func (format *ObjFormat) Unload(asset *Asset) error {
+	asset.LoadStatus.Reset()
+	return nil
+}
+func (format *ObjFormat) Activate(asset *Asset) error {
+	asset.ActivateStatus.Success()
+	return nil
+}
+func (format *ObjFormat) Deactivate(asset *Asset) error {
+	asset.ActivateStatus.Reset()
+	return nil
+}

pkg/asset-sources.go

@@ -0,0 +1,52 @@
+package axe
+
+import (
+	"io"
+	"net/http"
+	"os"
+	"regexp"
+)
+
+var relativeRegex, _ = regexp.Compile(`[^/]+$`)
+var previousRegex, _ = regexp.Compile(`[^/]+/\.\./`)
+
+type LocalAssetSource struct{}
+
+var _ AssetSource = &LocalAssetSource{}
+var localAssetSourceRegex, _ = regexp.Compile(`^(/|\./|[a-zA-Z]:)`)
+
+func (local *LocalAssetSource) Handles(ref AssetRef) bool {
+	return localAssetSourceRegex.MatchString(ref.URI)
+}
+func (local *LocalAssetSource) Read(ref AssetRef) (io.Reader, error) {
+	return os.Open(ref.URI)
+}
+func (local *LocalAssetSource) Relative(uri string, relative string) string {
+	uri = relativeRegex.ReplaceAllString(uri, relative)
+	uri = previousRegex.ReplaceAllString(uri, "")
+	return uri
+}
+
+type WebAssetSource struct{}
+
+var _ AssetSource = &WebAssetSource{}
+var webAssetSourceRegex, _ = regexp.Compile("^https?:")
+
+func (local *WebAssetSource) Handles(ref AssetRef) bool {
+	return webAssetSourceRegex.MatchString(ref.URI)
+}
+func (local *WebAssetSource) Read(ref AssetRef) (io.Reader, error) {
+	client := http.Client{
+		CheckRedirect: func(r *http.Request, via []*http.Request) error {
+			r.URL.Opaque = r.URL.Path
+			return nil
+		},
+	}
+	resp, err := client.Get(ref.URI)
+	return resp.Body, err
+}
+func (local *WebAssetSource) Relative(uri string, relative string) string {
+	uri = relativeRegex.ReplaceAllString(uri, relative)
+	uri = previousRegex.ReplaceAllString(uri, "")
+	return uri
+}