]> git.localhorst.tv Git - blank.git/blob - src/world/World.cpp
show player orientation in debug overlay
[blank.git] / src / world / World.cpp
1 #include "World.hpp"
2
3 #include "WorldCollision.hpp"
4 #include "../app/Assets.hpp"
5 #include "../app/TextureIndex.hpp"
6 #include "../graphics/Format.hpp"
7 #include "../graphics/Viewport.hpp"
8
9 #include <limits>
10 #include <glm/gtx/io.hpp>
11 #include <glm/gtx/transform.hpp>
12
13
14 namespace blank {
15
16 World::World(const Assets &assets, const Config &config, const WorldSave &save)
17 : block_type()
18 , block_tex()
19 , generate(config.gen)
20 , chunks(config.load, block_type, generate, save)
21 , player()
22 , entities()
23 , light_direction(config.light_direction)
24 , fog_density(config.fog_density) {
25         TextureIndex tex_index;
26         assets.LoadBlockTypes("default", block_type, tex_index);
27
28         block_tex.Bind();
29         assets.LoadTextures(tex_index, block_tex);
30         block_tex.FilterNearest();
31
32         generate.Space(0);
33         generate.Light(13);
34         generate.Solids({ 1, 4, 7, 10 });
35
36         player = &AddEntity();
37         player->Name("player");
38         player->Bounds({ { -0.5f, -0.5f, -0.5f }, { 0.5f, 0.5f, 0.5f } });
39         player->WorldCollidable(true);
40         player->Position(config.spawn);
41
42         chunks.QueueSurrounding(player->ChunkCoords());
43 }
44
45
46 namespace {
47
48 struct Candidate {
49         Chunk *chunk;
50         float dist;
51 };
52
53 std::vector<Candidate> candidates;
54
55 }
56
57 bool World::Intersection(
58         const Ray &ray,
59         const glm::mat4 &M,
60         Chunk *&chunk,
61         int &blkid,
62         float &dist,
63         glm::vec3 &normal
64 ) {
65         candidates.clear();
66
67         for (Chunk &cur_chunk : chunks.Loaded()) {
68                 float cur_dist;
69                 if (cur_chunk.Intersection(ray, M * cur_chunk.Transform(player->ChunkCoords()), cur_dist)) {
70                         candidates.push_back({ &cur_chunk, cur_dist });
71                 }
72         }
73
74         if (candidates.empty()) return false;
75
76         chunk = nullptr;
77         dist = std::numeric_limits<float>::infinity();
78         blkid = -1;
79
80         for (Candidate &cand : candidates) {
81                 if (cand.dist > dist) continue;
82                 int cur_blkid;
83                 float cur_dist;
84                 glm::vec3 cur_normal;
85                 if (cand.chunk->Intersection(ray, M * cand.chunk->Transform(player->ChunkCoords()), cur_blkid, cur_dist, cur_normal)) {
86                         if (cur_dist < dist) {
87                                 chunk = cand.chunk;
88                                 blkid = cur_blkid;
89                                 dist = cur_dist;
90                                 normal = cur_normal;
91                         }
92                 }
93         }
94
95         return chunk;
96 }
97
98 bool World::Intersection(const Entity &e, std::vector<WorldCollision> &col) {
99         AABB box = e.Bounds();
100         glm::mat4 M = e.Transform(player->ChunkCoords());
101         bool any = false;
102         // TODO: this only needs to check the chunks surrounding the entity's chunk position
103         //       need find out if that is quicker than the rough chunk bounds test
104         for (Chunk &cur_chunk : chunks.Loaded()) {
105                 if (cur_chunk.Intersection(box, M, cur_chunk.Transform(player->ChunkCoords()), col)) {
106                         any = true;
107                 }
108         }
109         return any;
110 }
111
112
113 Chunk &World::PlayerChunk() {
114         return chunks.ForceLoad(player->ChunkCoords());
115 }
116
117 Chunk &World::Next(const Chunk &to, const glm::ivec3 &dir) {
118         const Chunk::Pos tgt_pos = to.Position() + dir;
119         return chunks.ForceLoad(tgt_pos);
120 }
121
122
123 namespace {
124
125 std::vector<WorldCollision> col;
126
127 }
128
129 void World::Update(int dt) {
130         for (Entity &entity : entities) {
131                 entity.Update(dt);
132         }
133         for (Entity &entity : entities) {
134                 col.clear();
135                 if (entity.WorldCollidable() && Intersection(entity, col)) {
136                         // entity collides with the world
137                         Resolve(entity, col);
138                 }
139         }
140         for (auto iter = entities.begin(), end = entities.end(); iter != end;) {
141                 if (iter->CanRemove()) {
142                         iter = entities.erase(iter);
143                 } else {
144                         ++iter;
145                 }
146         }
147         chunks.Rebase(player->ChunkCoords());
148         chunks.Update(dt);
149 }
150
151 void World::Resolve(Entity &e, std::vector<WorldCollision> &col) {
152         // determine displacement for each cardinal axis and move entity accordingly
153         glm::vec3 min_disp(0.0f);
154         glm::vec3 max_disp(0.0f);
155         for (const WorldCollision &c : col) {
156                 if (!c.Blocks()) continue;
157                 glm::vec3 local_disp(c.normal * c.depth);
158                 // swap if neccessary (normal may point away from the entity)
159                 if (dot(c.normal, e.Position() - c.BlockCoords()) < 0) {
160                         local_disp *= -1;
161                 }
162                 min_disp = min(min_disp, local_disp);
163                 max_disp = max(max_disp, local_disp);
164         }
165         // for each axis
166         // if only one direction is set, use that as the final
167         // if both directions are set, use average
168         glm::vec3 final_disp(0.0f);
169         for (int axis = 0; axis < 3; ++axis) {
170                 if (std::abs(min_disp[axis]) > std::numeric_limits<float>::epsilon()) {
171                         if (std::abs(max_disp[axis]) > std::numeric_limits<float>::epsilon()) {
172                                 final_disp[axis] = (min_disp[axis] + max_disp[axis]) * 0.5f;
173                         } else {
174                                 final_disp[axis] = min_disp[axis];
175                         }
176                 } else if (std::abs(max_disp[axis]) > std::numeric_limits<float>::epsilon()) {
177                         final_disp[axis] = max_disp[axis];
178                 }
179         }
180         e.Move(final_disp);
181 }
182
183
184 void World::Render(Viewport &viewport) {
185         viewport.WorldPosition(player->Transform(player->ChunkCoords()));
186
187         BlockLighting &chunk_prog = viewport.ChunkProgram();
188         chunk_prog.SetTexture(block_tex);
189         chunk_prog.SetFogDensity(fog_density);
190
191         for (Chunk &chunk : chunks.Loaded()) {
192                 glm::mat4 m(chunk.Transform(player->ChunkCoords()));
193                 chunk_prog.SetM(m);
194                 glm::mat4 mvp(chunk_prog.GetVP() * m);
195                 if (!CullTest(Chunk::Bounds(), mvp)) {
196                         chunk.Draw();
197                 }
198         }
199
200         DirectionalLighting &entity_prog = viewport.EntityProgram();
201         entity_prog.SetLightDirection(light_direction);
202         entity_prog.SetFogDensity(fog_density);
203
204         for (Entity &entity : entities) {
205                 entity.Render(entity.ChunkTransform(player->ChunkCoords()), entity_prog);
206         }
207 }
208
209 }