/
level_asset.go
107 lines (95 loc) · 3.19 KB
/
level_asset.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
package pack
import (
"fmt"
"github.com/mokiat/gomath/dprec"
"github.com/mokiat/gomath/stod"
"github.com/mokiat/lacking/game/asset"
"github.com/mokiat/lacking/game/physics"
)
type SaveLevelAssetAction struct {
resource asset.Resource
levelProvider LevelProvider
}
func (a *SaveLevelAssetAction) Describe() string {
return fmt.Sprintf("save_level_asset(%q)", a.resource.Name())
}
func (a *SaveLevelAssetAction) Run() error {
level := a.levelProvider.Level()
conv := newConverter(false)
modelAsset := asset.Model{}
bodyDefinitions := make([]asset.BodyDefinition, len(level.CollisionMeshes))
bodyInstances := make([]asset.BodyInstance, len(level.CollisionMeshes))
for i, collisionMesh := range level.CollisionMeshes {
collisionMeshAsset := asset.CollisionMesh{
Triangles: make([]asset.CollisionTriangle, len(collisionMesh.Triangles)),
Translation: dprec.ZeroVec3(),
Rotation: dprec.IdentityQuat(),
}
for j, triangle := range collisionMesh.Triangles {
collisionMeshAsset.Triangles[j] = asset.CollisionTriangle{
A: stod.Vec3(triangle.A),
B: stod.Vec3(triangle.B),
C: stod.Vec3(triangle.C),
}
}
bodyDefinitions[i] = asset.BodyDefinition{
Name: fmt.Sprintf("static-%d", i),
Mass: 1.0,
MomentOfInertia: physics.SymmetricMomentOfInertia(1.0),
RestitutionCoefficient: 1.0,
DragFactor: 0.0,
AngularDragFactor: 0.0,
CollisionMeshes: []asset.CollisionMesh{
collisionMeshAsset,
},
}
bodyInstances[i] = asset.BodyInstance{
NodeIndex: -1,
BodyIndex: int32(i),
}
}
modelAsset.BodyDefinitions = bodyDefinitions
modelAsset.BodyInstances = bodyInstances
materials := make([]asset.Material, len(level.Materials))
for i, staticMaterial := range level.Materials {
materials[i] = conv.BuildMaterial(staticMaterial)
conv.assetMaterialIndexFromMaterial[staticMaterial] = i
}
modelAsset.Materials = materials
meshDefinitions := make([]asset.MeshDefinition, len(level.StaticMeshes))
meshInstances := make([]asset.MeshInstance, len(level.StaticMeshes))
for i, staticMesh := range level.StaticMeshes {
meshDefinitions[i] = conv.BuildMeshDefinition(staticMesh)
meshInstances[i] = asset.MeshInstance{
Name: staticMesh.Name,
NodeIndex: -1,
ArmatureIndex: -1,
DefinitionIndex: int32(i),
}
}
modelAsset.MeshDefinitions = meshDefinitions
modelAsset.MeshInstances = meshInstances
modelInstances := make([]asset.ModelInstance, len(level.StaticEntities))
for i, staticEntity := range level.StaticEntities {
t, r, s := stod.Mat4(staticEntity.Matrix).TRS()
modelInstances[i] = asset.ModelInstance{
ModelIndex: -1,
ModelID: staticEntity.Model,
Name: staticEntity.Name,
Translation: t,
Rotation: r,
Scale: s,
}
}
levelAsset := &asset.Scene{
SkyboxTexture: level.SkyboxTexture,
AmbientReflectionTexture: level.AmbientReflectionTexture,
AmbientRefractionTexture: level.AmbientRefractionTexture,
ModelInstances: modelInstances,
Model: modelAsset,
}
if err := a.resource.WriteContent(levelAsset); err != nil {
return fmt.Errorf("failed to write asset: %w", err)
}
return nil
}