aboutsummaryrefslogtreecommitdiffstats
path: root/src/world.cpp
diff options
context:
space:
mode:
Diffstat (limited to 'src/world.cpp')
-rw-r--r--src/world.cpp325
1 files changed, 186 insertions, 139 deletions
diff --git a/src/world.cpp b/src/world.cpp
index cd89a22..48e54e3 100644
--- a/src/world.cpp
+++ b/src/world.cpp
@@ -18,7 +18,7 @@
*/
#include "world.hpp"
-#include "events/render.hpp"
+
#include "events/world.hpp"
/*****************
@@ -55,131 +55,50 @@ World::World(sol::object param)
// If a generate function is defined, call it
if (generate != sol::nil)
generate(this);
-
- // Create our world VBO
- glGenBuffers(1, &worldVBO);
- // Generate our mesh
- generateMesh();
-}
-
-/* REGISTRY */
-void World::registerMaterial(std::string name, sol::object data)
-{
- if (data.get_type() == sol::type::table) {
- sol::table tab = data;
-
- // Make sure this material has not been registered before
- auto it = string_registry.find(name);
- if (it == string_registry.end()) {
- string_registry.emplace(name, registry.size());
- registry.push_back(WorldMaterial(tab));
- } else {
- std::cerr << "Material: " << name
- << " was already registered" << std::endl;
- }
- } else {
- // TODO better logging
- std::cerr << "Material registration must have a table" << std::endl;
- }
-}
-
-/* DATA */
-void World::setData(unsigned int x,
- unsigned int y,
- unsigned int z,
- std::string d)
-{
- unsigned int discovered = -1;
-
- auto found = string_registry.find(d);
- if (found != string_registry.end())
- discovered = found->second;
-
- try {
- data.at(z).at(x).at(y) = discovered;
- } catch (std::out_of_range &oor) {
- // Make sure any assignments that are outsize specified world size are
- // caught to avoid any seg faults
- std::cerr << "Unable to set data at: "
- << x << "," << y << "," << z
- << " Exception: " << oor.what() << std::endl;
- }
-}
-
-/* SIZE */
-std::tuple<unsigned int, unsigned int, unsigned int>
-World::setSize(unsigned int x, unsigned int y, unsigned int z)
-{
- width = x;
- height = y;
- layers = z;
-
- data = std::vector<std::vector<std::vector<int>>>
- (z, std::vector<std::vector<int>>
- (x,std::vector<int>
- (y, -1)
- )
- );
-
- return {width, height, layers};
}
+// TODO
std::tuple<unsigned int, unsigned int, unsigned int>
World::getSize()
{
- return {width, height, layers};
+ //return {width, height, layers};
+ return {0, 0, 0};
}
/* RENDERING */
void World::generateMesh()
{
- //const unsigned int voxelLength = 6; // 2 triangles @ 3 points each
-
- // Preallocate size of vertexes
- mesh = std::basic_string<WorldMeshData>();
- for (float Z = data.size() - 1; Z >= 0; Z--) {
- for (float X = 0; X < data.at(Z).size(); X++) {
- for (float Y = 0; Y < data.at(Z).at(X).size(); Y++) {
- int d = data.at(Z).at(X).at(Y);
-
- if (d == -1) // Don't make a mesh for air of course
- continue;
-
- Texture &t = registry.at(d).texture;
- glm::vec2& to = t.offset;
- glm::vec2& ts = t.size;
-
- float tr = 1.0f;
-
- // TODO play with this a bit so it only goes trans
- // if player is behind the front layer
- try {
- if (Z < data.size() - 1 && Z >= 0) {
- if (data.at(Z+1).at(X).at(Y) == -1)
- tr = 1.0f;
- }
- } catch (...) {
- tr = 1.0f;
- }
-
- mesh += {X , Y , Z, to.x , to.y+ts.y, tr};
- mesh += {X+1, Y , Z, to.x+ts.x, to.y+ts.y, tr};
- mesh += {X , Y+1, Z, to.x , to.y , tr};
-
- mesh += {X+1, Y , Z, to.x+ts.x, to.y+ts.y, tr};
- mesh += {X+1, Y+1, Z, to.x+ts.x, to.y , tr};
- mesh += {X , Y+1, Z, to.x , to.y , tr};
- }
- }
+ for (auto &l : drawLayers) {
+
+ // Preallocate size of vertexes
+
+ float Z = l->drawLayer;
+ auto to = l->texture.offset;
+ auto ts = l->texture.size;
+ float tr = 1.0f;
+
+ float w = l->texture.width/unitSize;
+ float h = l->texture.height/unitSize;
+
+ GLfloat mesh[36] = {0 , 0 , Z, to.x , to.y+ts.y, tr,
+ 0+w, 0 , Z, to.x+ts.x, to.y+ts.y, tr,
+ 0 , 0+h, Z, to.x , to.y , tr,
+
+ 0+w, 0 , Z, to.x+ts.x, to.y+ts.y, tr,
+ 0+w, 0+h, Z, to.x+ts.x, to.y , tr,
+ 0 , 0+h, Z, to.x , to.y , tr};
+
+ glBindBuffer(GL_ARRAY_BUFFER, l->layerVBO);
+ glBufferData(GL_ARRAY_BUFFER,
+ 36 * sizeof(GLfloat),
+ mesh,
+ GL_STATIC_DRAW);
+
+ meshAdd.push_back(WorldMeshUpdateEvent(l->layerVBO,
+ l->texture.tex,
+ l->normal.tex,
+ 36));
}
-
- glBindBuffer(GL_ARRAY_BUFFER, worldVBO);
- glBufferData(GL_ARRAY_BUFFER,
- mesh.size() * sizeof(WorldMeshData),
- mesh.data(),
- GL_STATIC_DRAW);
-
- meshUpdated = true;
}
/* SEED */
@@ -197,28 +116,160 @@ unsigned int World::setSeed(unsigned int s)
/* PHYSICS */
double World::getHeight(double x, double y, double z)
{
- unsigned int X = static_cast<unsigned int>(x);
- unsigned int Z = static_cast<unsigned int>(z);
-
- double Y = 0.0;
- try {
- auto &d = data.at(Z).at(X);
- for (int yi = d.size()-1; yi >= 0; yi--) {
- if (d.at(yi) >= 0) {
- if (!registry.at(d.at(yi)).passable) {
- Y = static_cast<double>(yi);
- Y += 1;
- break;
+ (void)y;
+ double Y = 0.0f;
+ for (auto &l : solidLayers) {
+ if (z == l->drawLayer) {
+ int wx = x*unitSize;
+
+ int h = 0.0;
+ for (auto b : l->hitbox[wx]) {
+ if (b == true)
+ Y = h;
+ h++;
+ }
+ return ((Y+1)/unitSize);
+ }
+ }
+ return 0;
+}
+
+bool World::isSolid(glm::vec3 pos)
+{
+ for (auto &l : solidLayers) {
+ if (pos.z == l->drawLayer) {
+ int wx = pos.x * unitSize;
+ int wy = pos.y * unitSize;
+ if (wx < 0 || wy < 0) return true;
+
+ return l->hitbox[wx][wy];
+ }
+ }
+ return false;
+}
+
+std::vector<glm::vec3>
+World::getIntersectingPlanes(glm::vec3 origin, Physics &phys)
+{
+ std::vector<glm::vec3> planes;
+
+ glm::vec3 goal = origin;
+
+ origin.x += phys.corners[0].x;
+ origin.y += phys.corners[0].y;
+
+ goal.x += phys.corners[3].x;
+ goal.y += phys.corners[3].y;
+
+ float step = 1.0f/unitSize;
+ for (;origin.y <= goal.y; origin.y += step){
+ for (;origin.x <= goal.x; origin.x += step) {
+ if (isSolid(origin)) {
+ planes.push_back(origin);
+ }
+ }
+ }
+
+ return planes;
+}
+
+glm::vec3 World::collide(glm::vec3 &start, glm::vec3 &end, Physics &phys)
+{
+ // How far to push the entity to unintersect with the world
+ glm::vec3 push(0);
+ for (auto &l : solidLayers) {
+ if (start.z == l->drawLayer) {
+ glm::vec3 len = end-start;
+ glm::vec3 dir = glm::normalize(len);
+ float step = 1.0f/unitSize;
+
+ glm::vec3 pos = start;
+
+ for (float i = 0.0f; i < glm::length(len); i+=step, pos+=dir) {
+ // Get all colliding world spaces
+ std::vector<glm::vec3> inter = getIntersectingPlanes(pos, phys);
+
+ if (i == 0.0f) {
+ std::cout << inter.size() << std::endl;
+ if (inter.size()) {
+ p.standing = true;
+ }
+ }
+
+ // If there are no colliding world spaces, don't bother
+ if (inter.size()) {
+ if (dir.x > 0.0f) {
+ // Moving to the right
+ int closest = inter.at(0).x;
+ for (auto &p : inter) {
+ if (p.x < closest)
+ closest = p.x;
+ }
+ push.x -= abs(closest - (pos.x + phys.corners[1].x));
+
+ } else if (dir.x < 0.0f) {
+ // Moving to the left
+ int closest = inter.at(0).x;
+ for (auto &p : inter) {
+ if (p.x > closest)
+ closest = p.x;
+ }
+ push.x += abs(closest - (pos.x + phys.corners[0].x));
+ }
+
+ if (dir.y > 0.0f) {
+ // Moving upwards
+ int closest = inter.at(0).y;
+ for (auto &p : inter) {
+ if (p.y < closest)
+ closest = p.y;
+ }
+ push.y -= abs(closest - (pos.y + phys.corners[2].y));
+ } else if (dir.y < 0.0f) {
+ // Moving downwards
+ int closest = inter.at(0).y;
+ for (auto &p : inter) {
+ if (p.y > closest)
+ closest = p.y;
+ }
+ push.y += abs(closest - (pos.y + phys.corners[0].y));
+ }
+
+ if (push != glm::vec3(0.0f))
+ return pos + push;
}
}
}
- } catch (...) { // If we get any errors, just let the character
- //return y;
- (void)y;
- return 0.0;
}
+ return end;
+}
+
- return Y;
+/*********
+* NEW *
+*********/
+void World::registerLayer(float z, sol::object obj)
+{
+ if (obj.get_type() == sol::type::table) {
+ sol::table tab = obj;
+ SolidLayer s(z, tab);
+ solidLayers.push_back(std::make_shared<SolidLayer>(s));
+ drawLayers.push_back(std::make_shared<Layer>(s));
+ } else {
+ throw std::string("Layer must receive a table");
+ }
+ generateMesh();
+}
+
+void World::registerDecoLayer(float z, sol::object obj)
+{
+ if (obj.get_type() == sol::type::table) {
+ sol::table tab = obj;
+ drawLayers.push_back(std::make_shared<Layer>(Layer(z, tab)));
+ } else {
+ throw std::string("Layer must receive a table");
+ }
+ generateMesh();
}
@@ -247,12 +298,8 @@ void WorldSystem::update([[maybe_unused]]entityx::EntityManager& entities,
events.emit<WorldChangeEvent>(currentWorld);
}
- if (currentWorld->meshUpdated) {
- events.emit<WorldMeshUpdateEvent>(
- currentWorld->worldVBO,
- currentWorld->mesh.size(),
- currentWorld->getTexture(),
- currentWorld->getNormal()
- );
+ for (auto &ma : currentWorld->meshAdd) {
+ events.emit<WorldMeshUpdateEvent>(ma);
}
+ currentWorld->meshAdd.clear();
}
generated by cgit v1.2.3 (git 2.39.1) at 2025-04-05 23:40:26 +0000