]> git.localhorst.tv Git - blank.git/blob - src/model/composite.cpp
transmit player input from client to server
[blank.git] / src / model / composite.cpp
1 #include "CompositeModel.hpp"
2 #include "CompositeInstance.hpp"
3 #include "Skeletons.hpp"
4
5 #include "EntityModel.hpp"
6 #include "shapes.hpp"
7 #include "../graphics/DirectionalLighting.hpp"
8
9 #include <glm/gtx/quaternion.hpp>
10
11
12 namespace blank {
13
14 CompositeModel::CompositeModel()
15 : parent(nullptr)
16 , node_model(nullptr)
17 , id(0)
18 , bounds{{ 0.0f, 0.0f, 0.0f }, { 0.0f, 0.0f, 0.0f }}
19 , position(0.0f)
20 , orientation(1.0f, 0.0f, 0.0f, 0.0f)
21 , parts() {
22
23 }
24
25
26 CompositeModel &CompositeModel::AddPart() {
27         parts.emplace_back();
28         parts.back().parent = this;
29         return parts.back();
30 }
31
32
33 glm::mat4 CompositeModel::LocalTransform() const noexcept {
34         glm::mat4 transform(toMat4(orientation));
35         transform[3].x = position.x;
36         transform[3].y = position.y;
37         transform[3].z = position.z;
38         return transform;
39 }
40
41 glm::mat4 CompositeModel::GlobalTransform() const noexcept {
42         if (HasParent()) {
43                 return Parent().GlobalTransform() * LocalTransform();
44         } else {
45                 return LocalTransform();
46         }
47 }
48
49
50 void CompositeModel::Instantiate(CompositeInstance &inst) const {
51         inst.part_model = this;
52         inst.position = position;
53         inst.orientation = orientation;
54         inst.parts.clear();
55         inst.parts.reserve(parts.size());
56         for (const CompositeModel &part : parts) {
57                 part.Instantiate(inst.AddPart());
58         }
59 }
60
61
62 CompositeInstance::CompositeInstance()
63 : part_model(nullptr)
64 , parent(nullptr)
65 , position(0.0f)
66 , orientation(1.0f, 0.0f, 0.0f, 0.0f)
67 , parts() {
68
69 }
70
71
72 CompositeInstance &CompositeInstance::AddPart() {
73         parts.emplace_back();
74         parts.back().parent = this;
75         return parts.back();
76 }
77
78
79 glm::mat4 CompositeInstance::LocalTransform() const noexcept {
80         glm::mat4 transform(toMat4(orientation));
81         transform[3].x = position.x;
82         transform[3].y = position.y;
83         transform[3].z = position.z;
84         return transform;
85 }
86
87 glm::mat4 CompositeInstance::GlobalTransform() const noexcept {
88         if (HasParent()) {
89                 return Parent().GlobalTransform() * LocalTransform();
90         } else {
91                 return LocalTransform();
92         }
93 }
94
95
96 void CompositeInstance::Render(const glm::mat4 &M, DirectionalLighting &prog) const {
97         glm::mat4 transform(M * LocalTransform());
98         if (part_model->HasNodeModel()) {
99                 prog.SetM(transform);
100                 part_model->NodeModel().Draw();
101         }
102         for (const CompositeInstance &part : parts) {
103                 part.Render(transform, prog);
104         }
105 }
106
107
108 Skeletons::Skeletons()
109 : skeletons()
110 , models() {
111
112 }
113
114 Skeletons::~Skeletons() {
115
116 }
117
118 void Skeletons::LoadHeadless() {
119         skeletons.clear();
120         skeletons.reserve(4);
121         {
122                 AABB bounds{{ -0.5f, -0.5f, -0.5f }, { 0.5f, 0.5f, 0.5f }};
123                 skeletons.emplace_back(new CompositeModel);
124                 skeletons[0]->ID(1);
125                 skeletons[0]->Bounds(bounds);
126         }
127         {
128                 AABB bounds{{ -0.5f, -0.25f, -0.5f }, { 0.5f, 0.25f, 0.5f }};
129                 skeletons.emplace_back(new CompositeModel);
130                 skeletons[1]->ID(2);
131                 skeletons[1]->Bounds(bounds);
132         }
133         {
134                 AABB bounds{{ -0.25f, -0.5f, -0.25f }, { 0.25f, 0.5f, 0.25f }};
135                 skeletons.emplace_back(new CompositeModel);
136                 skeletons[2]->ID(3);
137                 skeletons[2]->Bounds(bounds);
138         }
139         {
140                 AABB bounds{{ -0.25f, -0.5f, -0.35f }, { 0.25f, 0.5f, 0.35f }};
141                 skeletons.emplace_back(new CompositeModel);
142                 skeletons[3]->ID(4);
143                 skeletons[3]->Bounds(bounds);
144         }
145 }
146
147 void Skeletons::Load() {
148         LoadHeadless();
149         models.resize(4);
150         EntityModel::Buffer buf;
151         {
152                 CuboidShape shape(skeletons[0]->Bounds());
153                 shape.Vertices(buf, 3.0f);
154                 buf.colors.resize(shape.VertexCount(), { 1.0f, 1.0f, 0.0f });
155                 models[0].Update(buf);
156                 skeletons[0]->SetNodeModel(&models[0]);
157         }
158         {
159                 CuboidShape shape(skeletons[1]->Bounds());
160                 buf.Clear();
161                 shape.Vertices(buf, 0.0f);
162                 buf.colors.resize(shape.VertexCount(), { 0.0f, 1.0f, 1.0f });
163                 models[1].Update(buf);
164                 skeletons[1]->SetNodeModel(&models[1]);
165         }
166         {
167                 StairShape shape(skeletons[2]->Bounds(), { 0.4f, 0.4f });
168                 buf.Clear();
169                 shape.Vertices(buf, 1.0f);
170                 buf.colors.resize(shape.VertexCount(), { 1.0f, 0.0f, 1.0f });
171                 models[2].Update(buf);
172                 skeletons[2]->SetNodeModel(&models[2]);
173         }
174         {
175                 CuboidShape shape(skeletons[3]->Bounds());
176                 buf.Clear();
177                 shape.Vertices(buf, 2.0f);
178                 buf.colors.resize(shape.VertexCount(), { 1.0f, 0.25f, 0.5f });
179                 models[3].Update(buf);
180                 skeletons[3]->SetNodeModel(&models[3]);
181         }
182 }
183
184 CompositeModel *Skeletons::ByID(std::uint16_t id) noexcept {
185         if (id == 0 || id > skeletons.size()) {
186                 return nullptr;
187         } else {
188                 return skeletons[id - 1].get();
189         }
190 }
191
192 const CompositeModel *Skeletons::ByID(std::uint16_t id) const noexcept {
193         if (id == 0 || id > skeletons.size()) {
194                 return nullptr;
195         } else {
196                 return skeletons[id - 1].get();
197         }
198 }
199
200 }