354 lines
10 KiB
C++
354 lines
10 KiB
C++
#include "planet/PlanetFace.h"
|
|
#include <time.h>
|
|
#include <math.h>
|
|
|
|
// Correlates directly to Face enum
|
|
const glm::vec3 FACE_NORMALS[6] = {
|
|
// FACE_BOTTOM
|
|
glm::vec3(0.0f, -1.0f, 0.0f),
|
|
// FACE_TOP
|
|
glm::vec3(0.0f, 1.0f, 0.0f),
|
|
// FACE_LEFT
|
|
glm::vec3(-1.0f, 0.0f, 0.0f),
|
|
// FACE_RIGHT
|
|
glm::vec3(1.0f, 0.0f, 0.0f),
|
|
// FACE_FRONT
|
|
glm::vec3(0.0f, 0.0f, -1.0f),
|
|
// FACE_BACK
|
|
glm::vec3(0.0f, 0.0f, 1.0f)
|
|
};
|
|
|
|
PlanetFaceNode::PlanetFaceNode(Planet* planet, PlanetFace* face, glm::vec3 position, const unsigned int index, const unsigned int level) :
|
|
m_planet(planet), m_planetFace(face), m_pos(position), m_index(index), m_level(level), m_generated(false), m_dirty(true), m_leaf(true)
|
|
{
|
|
glm::vec3 normal = face->getNormal();
|
|
|
|
// normal 0 1 0 left 1 0 0 forward 0 0 -1
|
|
// normal 0 0 -1 left 0 -1 0 forward -1 0 0
|
|
m_left = glm::vec3(normal.y, normal.z, normal.x);
|
|
m_forward = glm::cross(normal, m_left);
|
|
|
|
generate();
|
|
}
|
|
|
|
PlanetFaceNode::~PlanetFaceNode()
|
|
{
|
|
if (!m_leaf)
|
|
{
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
delete m_children[i];
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
void PlanetFaceNode::tick(Camera* camera, GLfloat dtime)
|
|
{
|
|
// TODO: based on planet transform
|
|
float camToOrigin = glm::distance(camera->getPosition(), (m_planet->getPosition() + m_center));
|
|
float divisionLevel = (float)pow(2, m_level);
|
|
float splitDistance = m_planet->getRadius() / divisionLevel;
|
|
if (camToOrigin < splitDistance * 1.5 && m_leaf) {
|
|
this->subdivide();
|
|
return;
|
|
} else if (camToOrigin > splitDistance * 2.0 && !m_leaf) {
|
|
this->merge();
|
|
return;
|
|
}
|
|
|
|
if (!m_leaf)
|
|
{
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
m_children[i]->tick(camera, dtime);
|
|
}
|
|
}
|
|
}
|
|
|
|
void PlanetFaceNode::setIndexBuffer(PlanetBufferIndex buf) {
|
|
PIB* indx = m_planet->getBuffers()->getBuffer(buf);
|
|
m_ebo = indx->ebo;
|
|
m_indices = indx->indices.size();
|
|
}
|
|
|
|
void PlanetFaceNode::draw(Camera* camera, Shader* shader)
|
|
{
|
|
// TODO: occlusion culling
|
|
if (!m_leaf)
|
|
{
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
m_children[i]->draw(camera, shader);
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (!m_generated)
|
|
return;
|
|
|
|
shader->setBuffers(m_vao, m_vbo, m_ebo);
|
|
shader->use();
|
|
|
|
camera->shaderViewProjection(*shader);
|
|
shader->setUniform("modelMatrix", m_planet->getTransformation());
|
|
|
|
glDrawElements(GL_TRIANGLES, m_indices, GL_UNSIGNED_INT, nullptr);
|
|
}
|
|
|
|
void PlanetFaceNode::generate()
|
|
{
|
|
if (m_generated)
|
|
return;
|
|
|
|
std::vector<Vertex> vertices;
|
|
|
|
float divisionLevel = (float)pow(2.0, m_level);
|
|
float radius = m_planet->getRadius();
|
|
for (int i = 0; i < RESOLUTION; i++)
|
|
{
|
|
for (int j = 0; j < RESOLUTION; j++)
|
|
{
|
|
// Get the 2D index of the vertex on the plane from zero to one (1 = RESOLUTION - 1)
|
|
glm::vec2 index = glm::vec2(i, j) / (RESOLUTION - 1.0f);
|
|
|
|
// Generate the vertices on the plane using left and forward vectors.
|
|
// here 2 * index - 1 is used to convert 0 - 1 to -1 - 1, that is to
|
|
// generate the vertices starting from the center point of the unit plane.
|
|
glm::vec3 iv = (m_forward * (2.0f * index.x - 1.0f)) / divisionLevel;
|
|
glm::vec3 jv = (m_left * (2.0f * index.y - 1.0f)) / divisionLevel;
|
|
|
|
// Add the unit left and forward vectors to the origin, m_pos here
|
|
// being the center point, which in division level zero is the offset
|
|
// normal from the center of the cube.
|
|
glm::vec3 vertex = m_pos + jv + iv;
|
|
|
|
// Normalize and multiply by radius to create a spherical mesh (unit sphere)
|
|
float x2 = vertex.x * vertex.x;
|
|
float y2 = vertex.y * vertex.y;
|
|
float z2 = vertex.z * vertex.z;
|
|
glm::vec3 point = glm::vec3(
|
|
vertex.x * sqrt(1.0f - ((y2 + z2) / 2.0f) + ((y2 * z2) / 3.0f)),
|
|
vertex.y * sqrt(1.0f - ((z2 + x2) / 2.0f) + ((z2 * x2) / 3.0f)),
|
|
vertex.z * sqrt(1.0f - ((x2 + y2) / 2.0f) + ((x2 * y2) / 3.0f))
|
|
);
|
|
|
|
// Get noise height and multiply by radius
|
|
float height = m_planet->getNoise().fractal(8, point.x, point.y, point.z) * 20.0f;
|
|
glm::vec3 pos = -(height + radius) * point;
|
|
|
|
// Add vertex
|
|
vertices.push_back({ pos, point, glm::vec2(j * (1.0 / RESOLUTION), i * (1.0 / RESOLUTION)) });
|
|
|
|
// Set center
|
|
if ((i == RESOLUTION / 2 && j == RESOLUTION / 2))
|
|
m_center = pos;
|
|
}
|
|
}
|
|
|
|
glGenVertexArrays(1, &m_vao);
|
|
glBindVertexArray(m_vao);
|
|
|
|
glGenBuffers(1, &m_vbo);
|
|
|
|
glBindBuffer(GL_ARRAY_BUFFER, m_vbo);
|
|
glBufferData(GL_ARRAY_BUFFER, sizeof(Vertex) * vertices.size(), &(vertices[0]), GL_STATIC_DRAW);
|
|
|
|
m_generated = true;
|
|
setIndexBuffer(PlanetBufferIndex::Base);
|
|
}
|
|
|
|
bool PlanetFaceNode::subdivide()
|
|
{
|
|
if (m_level == 8)
|
|
return false;
|
|
|
|
int lv = m_level + 1;
|
|
|
|
// Calculate distance to move the vertices on the unit plane based on division level
|
|
glm::vec3 stepLeft = m_left * (1.0f / (float)pow(2, lv));
|
|
glm::vec3 stepForward = m_forward * (1.0f / (float)pow(2, lv));
|
|
|
|
m_children[TOP_LEFT] = new PlanetFaceNode(m_planet, m_planetFace, m_pos + stepForward - stepLeft, TOP_LEFT, lv);
|
|
m_children[TOP_RIGHT] = new PlanetFaceNode(m_planet, m_planetFace, m_pos - stepForward - stepLeft, TOP_RIGHT, lv);
|
|
m_children[BOTTOM_RIGHT] = new PlanetFaceNode(m_planet, m_planetFace, m_pos - stepForward + stepLeft, BOTTOM_RIGHT, lv);
|
|
m_children[BOTTOM_LEFT] = new PlanetFaceNode(m_planet, m_planetFace, m_pos + stepForward + stepLeft, BOTTOM_LEFT, lv);
|
|
|
|
m_leaf = false;
|
|
|
|
for (int i = 0; i < 4; i++)
|
|
m_children[i]->m_parent = this;
|
|
|
|
this->dispose();
|
|
|
|
return true;
|
|
}
|
|
|
|
bool PlanetFaceNode::merge()
|
|
{
|
|
// Leaves don't ever need to be merged
|
|
if (m_leaf)
|
|
return false;
|
|
|
|
// Merge and dispose the children
|
|
for (int i = 0; i < 4; i++)
|
|
{
|
|
m_children[i]->dispose();
|
|
delete m_children[i];
|
|
}
|
|
|
|
// We're a leaf now
|
|
m_leaf = true;
|
|
generate();
|
|
return true;
|
|
}
|
|
|
|
void PlanetFaceNode::dispose()
|
|
{
|
|
m_generated = false;
|
|
}
|
|
|
|
bool PlanetFaceNode::isLeaf()
|
|
{
|
|
return m_leaf;
|
|
}
|
|
|
|
void PlanetFaceNode::getNeighbors() {
|
|
if (m_level == 0)
|
|
{
|
|
// The m_neighbors of root nodes never change
|
|
if (m_neighborTop != nullptr) return;
|
|
std::cout << m_planet->getFace(FACE_TOP)->getLODRoot() << std::endl;
|
|
switch (m_index)
|
|
{
|
|
// Front face
|
|
case FACE_FRONT:
|
|
m_neighborTop = m_planet->getFace(FACE_TOP)->getLODRoot();
|
|
m_neighborLeft = m_planet->getFace(FACE_LEFT)->getLODRoot();
|
|
m_neighborRight = m_planet->getFace(FACE_RIGHT)->getLODRoot();
|
|
m_neighborBottom = m_planet->getFace(FACE_BOTTOM)->getLODRoot();
|
|
break;
|
|
// Back face
|
|
case FACE_BACK:
|
|
m_neighborTop = m_planet->getFace(FACE_TOP)->getLODRoot();
|
|
m_neighborLeft = m_planet->getFace(FACE_RIGHT)->getLODRoot();
|
|
m_neighborRight = m_planet->getFace(FACE_LEFT)->getLODRoot();
|
|
m_neighborBottom = m_planet->getFace(FACE_BOTTOM)->getLODRoot();
|
|
break;
|
|
// Left face
|
|
case FACE_LEFT:
|
|
m_neighborTop = m_planet->getFace(FACE_TOP)->getLODRoot();
|
|
m_neighborLeft = m_planet->getFace(FACE_BACK)->getLODRoot();
|
|
m_neighborRight = m_planet->getFace(FACE_FRONT)->getLODRoot();
|
|
m_neighborBottom = m_planet->getFace(FACE_BOTTOM)->getLODRoot();
|
|
break;
|
|
// Right face
|
|
case FACE_RIGHT:
|
|
m_neighborTop = m_planet->getFace(FACE_TOP)->getLODRoot();
|
|
m_neighborLeft = m_planet->getFace(FACE_FRONT)->getLODRoot();
|
|
m_neighborRight = m_planet->getFace(FACE_BACK)->getLODRoot();
|
|
m_neighborBottom = m_planet->getFace(FACE_BOTTOM)->getLODRoot();
|
|
break;
|
|
// Top face
|
|
case FACE_TOP:
|
|
m_neighborTop = m_planet->getFace(FACE_BACK)->getLODRoot();
|
|
m_neighborLeft = m_planet->getFace(FACE_LEFT)->getLODRoot();
|
|
m_neighborRight = m_planet->getFace(FACE_RIGHT)->getLODRoot();
|
|
m_neighborBottom = m_planet->getFace(FACE_FRONT)->getLODRoot();
|
|
break;
|
|
// Bottom face
|
|
case FACE_BOTTOM:
|
|
m_neighborTop = m_planet->getFace(FACE_FRONT)->getLODRoot();
|
|
m_neighborLeft = m_planet->getFace(FACE_LEFT)->getLODRoot();
|
|
m_neighborRight = m_planet->getFace(FACE_RIGHT)->getLODRoot();
|
|
m_neighborBottom = m_planet->getFace(FACE_BACK)->getLODRoot();
|
|
break;
|
|
}
|
|
return;
|
|
}
|
|
|
|
if (m_parent == nullptr) return;
|
|
|
|
switch (m_index)
|
|
{
|
|
// Top left corner
|
|
case TOP_LEFT:
|
|
if (m_parent->m_neighborTop != nullptr)
|
|
m_neighborTop = m_parent->m_neighborTop->m_children[BOTTOM_LEFT];
|
|
|
|
if (m_parent->m_children[TOP_RIGHT] != nullptr)
|
|
m_neighborRight = m_parent->m_children[TOP_RIGHT];
|
|
|
|
if (m_parent->m_children[BOTTOM_LEFT] != nullptr)
|
|
m_neighborBottom = m_parent->m_children[BOTTOM_LEFT];
|
|
|
|
if (m_parent->m_neighborLeft != nullptr)
|
|
m_neighborLeft = m_parent->m_neighborLeft->m_children[TOP_RIGHT];
|
|
break;
|
|
// Top right corner
|
|
case TOP_RIGHT:
|
|
if (m_parent->m_neighborTop != nullptr)
|
|
m_neighborTop = m_parent->m_neighborTop->m_children[BOTTOM_RIGHT];
|
|
|
|
if (m_parent->m_neighborRight != nullptr)
|
|
m_neighborRight = m_parent->m_neighborRight->m_children[TOP_LEFT];
|
|
|
|
if (m_parent->m_children[BOTTOM_RIGHT] != nullptr)
|
|
m_neighborBottom = m_parent->m_children[BOTTOM_RIGHT];
|
|
|
|
if (m_parent->m_children[TOP_LEFT] != nullptr)
|
|
m_neighborLeft = m_parent->m_children[TOP_LEFT];
|
|
break;
|
|
// Bottom right corner
|
|
case BOTTOM_RIGHT:
|
|
if (m_parent->m_children[TOP_RIGHT] != nullptr)
|
|
m_neighborTop = m_parent->m_children[TOP_RIGHT];
|
|
|
|
if (m_parent->m_neighborRight != nullptr)
|
|
m_neighborRight = m_parent->m_neighborRight->m_children[BOTTOM_LEFT];
|
|
|
|
if (m_parent->m_neighborBottom != nullptr)
|
|
m_neighborBottom = m_parent->m_neighborBottom->m_children[TOP_RIGHT];
|
|
|
|
if (m_parent->m_children[BOTTOM_LEFT] != nullptr)
|
|
m_neighborLeft = m_parent->m_children[BOTTOM_LEFT];
|
|
break;
|
|
// Bottom left corner
|
|
case BOTTOM_LEFT:
|
|
if (m_parent->m_children[TOP_RIGHT] != nullptr)
|
|
m_neighborTop = m_parent->m_children[TOP_RIGHT];
|
|
|
|
if (m_parent->m_children[BOTTOM_RIGHT] != nullptr)
|
|
m_neighborRight = m_parent->m_children[BOTTOM_RIGHT];
|
|
|
|
if (m_parent->m_neighborBottom != nullptr)
|
|
m_neighborBottom = m_parent->m_neighborBottom->m_children[TOP_RIGHT];
|
|
|
|
if (m_parent->m_neighborLeft != nullptr)
|
|
m_neighborLeft = m_parent->m_neighborLeft->m_children[BOTTOM_RIGHT];
|
|
break;
|
|
}
|
|
}
|
|
|
|
PlanetFace::PlanetFace(Planet* planet, const unsigned int face) :
|
|
m_planet(planet), m_face(face)
|
|
{
|
|
m_normal = FACE_NORMALS[m_face];
|
|
m_lod = new PlanetFaceNode(planet, this, m_normal, face, 0);
|
|
}
|
|
|
|
PlanetFace::~PlanetFace()
|
|
{
|
|
delete m_lod;
|
|
}
|
|
|
|
void PlanetFace::draw(Camera* camera, Shader* shader)
|
|
{
|
|
m_lod->draw(camera, shader);
|
|
}
|
|
|
|
void PlanetFace::tick(Camera* camera, GLfloat dtime)
|
|
{
|
|
m_lod->tick(camera, dtime);
|
|
}
|