leca/TimeCoil
1
1
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

a lot of bug fixes, camera, etc...

Browse Source
This commit is contained in:
leca
2025-11-16 01:42:54 +03:00
parent 701ff99000
commit 1e11e66d16
12 changed files with 472 additions and 390 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
.vscode/launch.json vendored
View File

@@ -8,9 +8,9 @@
"type": "lldb", "type": "lldb",
"request": "launch", "request": "launch",
"name": "Debug", "name": "Debug",
"program": "${workspaceFolder}/<executable file>", "program": "${workspaceFolder}/build/TimeCoil",
"args": [], "args": [],
"cwd": "${workspaceFolder}" "cwd": "${workspaceFolder}/build"
} }
] ]
} }

1
CMakeLists.txt
View File

@@ -8,6 +8,7 @@ SET(PROJECT_SOURCES ${CMAKE_CURRENT_SOURCE_DIR}/src/main.cpp src/glad.c
${CMAKE_CURRENT_SOURCE_DIR}/src/coil/coil.cpp ${CMAKE_CURRENT_SOURCE_DIR}/src/coil/coil.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/coil/segment.cpp ${CMAKE_CURRENT_SOURCE_DIR}/src/coil/segment.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/utils/utils.cpp ${CMAKE_CURRENT_SOURCE_DIR}/src/utils/utils.cpp
${CMAKE_CURRENT_SOURCE_DIR}/src/camera/camera.cpp
) )
include_directories(${CMAKE_CURRENT_SOURCE_DIR}/src include_directories(${CMAKE_CURRENT_SOURCE_DIR}/src

6
build.sh
View File

@@ -1,2 +1,6 @@
#!/usr/bin/env bash #!/usr/bin/env bash
mkdir -p build && cd build && cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=ON -DCMAKE_C_FLAGS="-g -v -da -Q -O0" .. && make && ./TimeCoil # > ../points.csv && python ../tools/build_3d.py ../points.csv mkdir -p build && \
cd build && \
cmake -DCMAKE_EXPORT_COMPILE_COMMANDS=ON -DCMAKE_C_FLAGS="-g -v -da -Q -O0" .. && \
make && \
./TimeCoil # > ../points.csv && python ../tools/build_3d.py ../points.csv

82
src/camera/camera.cpp Normal file
View File

@@ -0,0 +1,82 @@
#include <GLFW/glfw3.h>
#include <camera/camera.hpp>
#include <glm/gtc/matrix_transform.hpp>
Camera::Camera(glm::vec3 pos, glm::vec3 up, float yaw, float pitch, float speed,
float sensitivity, CameraType type)
: pos(pos), worldUp(up), yaw(yaw), pitch(pitch), speed(speed), sensitivity(sensitivity), type(type) {
updateCameraVectors();
}
glm::mat4 Camera::getViewMatrix() { return glm::lookAt(pos, pos + front, up); }
void Camera::processKeyboardInput(CameraMovement direction) {
if (lastTime == -1) {
lastTime = glfwGetTime();
}
float deltaTime = glfwGetTime() - lastTime;
float velocity = speed * deltaTime;
switch (type) {
case CameraType::FREE: {
switch (direction) {
case CameraMovement::FORWARD:
pos += front * velocity;
break;
case CameraMovement::BACKWARD:
pos -= front * velocity;
break;
case CameraMovement::LEFT:
pos -= right * velocity;
break;
case CameraMovement::RIGHT:
pos += right * velocity;
break;
}
break;
}
case CameraType::SPINNING: {
}
}
lastTime = glfwGetTime();
}
void Camera::processMouseInput(GLFWwindow *window, double mouseX, double mouseY) {
switch (type) {
case CameraType::FREE: {
float dX = 0, dY = 0;
if (prevX == -1 && prevY == -1) {
prevX = mouseX;
prevY = mouseY;
}
dX = sensitivity * (mouseX - prevX);
dY = -sensitivity * (mouseY - prevY);
yaw += dX;
pitch += dY;
pitch = glm::clamp(pitch, (float)-89., (float)89.);
prevX = mouseX;
prevY = mouseY;
}
case CameraType::SPINNING: {
}
}
updateCameraVectors();
}
void Camera::updateCameraVectors() {
glm::vec3 front;
front.x = cos(glm::radians(yaw)) * cos(glm::radians(pitch));
front.y = sin(glm::radians(pitch));
front.z = sin(glm::radians(yaw)) * cos(glm::radians(pitch));
// front = glm::vec3(0, 0, 10);
this->front = glm::normalize(front);
right = glm::normalize(glm::cross(front, worldUp));
up = glm::normalize(glm::cross(right, front));
}

36
src/camera/camera.hpp Normal file
View File

@@ -0,0 +1,36 @@
#ifndef COIL_CAMERA_HPP
#define COIL_CAMERA_HPP
#include <GLFW/glfw3.h>
#include <glm/glm.hpp>
enum CameraType { FREE, SPINNING };
enum CameraMovement {
FORWARD,
BACKWARD,
LEFT,
RIGHT
};
class Camera {
float pitch, yaw;
float prevX = -1, prevY = -1;
glm::vec3 pos, front, up, right, worldUp;
CameraType type;
float lastTime = -1;
float speed, sensitivity;
public:
Camera(glm::vec3 pos, glm::vec3 up, float yaw, float pitch, float speed, float sensitivity, CameraType type);
glm::mat4 getViewMatrix();
void processKeyboardInput(CameraMovement direction);
void processMouseInput(GLFWwindow *window, double offsetX, double offsetY);
private:
void updateCameraVectors();
};
#endif // COIL_CAMERA_HPP

134
src/coil/coil.cpp
View File

@@ -1,32 +1,28 @@
#include <cstdint>
#include <glad/glad.h>
#include <GLFW/glfw3.h>
#include <iostream>
#include <coil/coil.hpp> #include <coil/coil.hpp>
#include <GLFW/glfw3.h>
#include <coil/segment.hpp> #include <coil/segment.hpp>
#include <cstdint>
#include <cstring>
#include <glad/glad.h>
#include <iostream>
#include <utils/utils.hpp> #include <utils/utils.hpp>
Coil::Coil(uint32_t currentYear, uint32_t amountOfSegments, uint32_t sliceDetalization, float radius, float width) Coil::Coil(uint32_t currentYear, uint32_t amountOfSegments, float segmentHeight, uint32_t sliceDetalization, float radius, float width)
: radius(radius), width(width), currentYear(currentYear) { : radius(radius), width(width), segmentHeight(segmentHeight), currentYear(currentYear) {
for (short i = amountOfSegments / -2.; i < amountOfSegments / 2.; i++) { for (short i = amountOfSegments / -2.; i < amountOfSegments / 2.; i++) {
uint32_t year = this->currentYear + i; uint32_t year = this->currentYear + i;
segments.push_back(CoilSegment(this, year, segmentHeight, i, sliceDetalization,false)); segments.push_back(CoilSegment(this, year, segmentHeight, i, sliceDetalization));
} }
}; };
std::vector<CoilSegment> &Coil::getSegments() { std::vector<CoilSegment> &Coil::getSegments() { return segments; }
return segments;
}
float Coil::getWidth() { float Coil::getWidth() { return width; }
return width;
}
float Coil::getRadius() { float Coil::getRadius() { return radius; }
return radius;
}
void Coil::initGLBuffers() { void Coil::initGLBuffers() {
@@ -39,12 +35,14 @@ void Coil::initGLBuffers() {
glBindBuffer(GL_ARRAY_BUFFER, VBO); glBindBuffer(GL_ARRAY_BUFFER, VBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO); glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
// glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW); // glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices,
// GL_STATIC_DRAW);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0); glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void *)0);
glEnableVertexAttribArray(0); glEnableVertexAttribArray(0);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*) (3 * sizeof(float))); glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float),
(void *)(3 * sizeof(float)));
glEnableVertexAttribArray(1); glEnableVertexAttribArray(1);
glBindVertexArray(0); glBindVertexArray(0);
@@ -52,15 +50,93 @@ void Coil::initGLBuffers() {
void Coil::render() { void Coil::render() {
glBindVertexArray(VAO); glBindVertexArray(VAO);
std::cout << "Rendering a coil." << std::endl; uint64_t verticesLength = 0;
for (CoilSegment segment : segments) { for (CoilSegment &segment : segments) {
std::cout << "Rendering " << segment.getYear() << std::endl; verticesLength += segment.getVerticesLength();
segment.fillVBO();
uint64_t indicesCount = segment.fillEBO(EBO);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
// glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
// glDrawArrays(GL_POINTS, 0, segment.getVerticesLength());
glDrawElements(GL_TRIANGLES_ADJACENCY, sizeof(unsigned int)*indicesCount, GL_UNSIGNED_INT, 0);
} }
float *vertices = (float *) malloc(verticesLength * sizeof(float));
if (vertices == NULL) {
std::cerr << "Couldn't allocate memory for vertices." << std::endl;
}
fillVBO(vertices);
uint32_t indicesAmount = fillEBO();
glDrawElements(GL_TRIANGLES, indicesAmount,
GL_UNSIGNED_INT, 0);
glBindVertexArray(0); glBindVertexArray(0);
free(vertices);
}
void Coil::fillVBO(float *vertices) {
uint64_t verticesSize = 0;
for (CoilSegment &segment : segments) {
float *segmentVertices = segment.getVertices();
uint32_t segmentVerticesLength = segment.getVerticesLength();
uint32_t segmentVerticesSize = segmentVerticesLength * sizeof(float);
memcpy(&vertices[verticesSize], segmentVertices, segmentVerticesSize);
verticesSize += segmentVerticesLength;
}
glBufferData(GL_ARRAY_BUFFER, verticesSize * sizeof(float), vertices, GL_STATIC_DRAW);
}
uint32_t Coil::fillEBO() {
uint32_t indicesLength = 0;
for (CoilSegment &segment : segments) {
indicesLength += segment.getDaysAmount() * segment.getSlicePointsAmount() * 6;
}
uint32_t *indices = (uint32_t *)malloc(indicesLength * sizeof(uint32_t));
uint32_t currentIndex = 0;
uint32_t yearOffset = 0;
for (uint32_t segmentNumber = 0; segmentNumber < segments.size(); segmentNumber++) {
CoilSegment &segment = segments[segmentNumber];
uint32_t slicePointsAmount = segment.getSlicePointsAmount();
for (uint32_t day = 0; day < segment.getDaysAmount(); day++) {
for (uint32_t pointOfSlice = 0; pointOfSlice < slicePointsAmount; pointOfSlice++) {
uint32_t dayOffset = day * slicePointsAmount;
uint32_t currentPointIndex = yearOffset + dayOffset + pointOfSlice - 1;
// First triangle
indices[currentIndex] = currentPointIndex;
currentIndex++;
indices[currentIndex] = currentPointIndex + slicePointsAmount;
currentIndex++;
indices[currentIndex] = currentPointIndex + 1;
currentIndex++;
// Second triangle
//if (pointOfSlice % (sliceDetalization+1) == 0 && pointOfSlice != 0) {
if (pointOfSlice == segment.getSliceDetailization() - 1 &&
pointOfSlice != 0) {
indices[currentIndex] = currentPointIndex - (slicePointsAmount - 1);
currentIndex++;
indices[currentIndex] = currentPointIndex + 1;
currentIndex++;
indices[currentIndex] = currentPointIndex;
} else {
indices[currentIndex] = currentPointIndex + 1;
currentIndex++;
indices[currentIndex] = currentPointIndex + slicePointsAmount + 1;
currentIndex++;
indices[currentIndex] = currentPointIndex + slicePointsAmount;
}
currentIndex++;
}
}
yearOffset += segment.getVerticesAmount();
}
if (currentIndex != indicesLength) {
std::cerr << "currentIndex == indicesLength assertion failed" << std::endl;
std::cerr << currentIndex << " " << indicesLength << std::endl;
}
// glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(uint32_t) * indicesLength, indices, GL_STATIC_DRAW);
free(indices);
return indicesLength;
} }

6
src/coil/coil.hpp
View File

@@ -5,6 +5,7 @@
#ifndef COIL_HPP #ifndef COIL_HPP
#define COIL_HPP #define COIL_HPP
// Coil segment is a one turn of a coil // Coil segment is a one turn of a coil
// Coil slice is a set of points that define slice of coil // Coil slice is a set of points that define slice of coil
@@ -20,11 +21,14 @@ class Coil {
GLuint VBO, VAO, EBO; GLuint VBO, VAO, EBO;
public: public:
Coil(uint32_t currentYear, uint32_t amountOfSegments, uint32_t sliceDetalization, float radius, float width); Coil(uint32_t currentYear, uint32_t amountOfSegments, float segmentHeight, uint32_t sliceDetalization, float radius, float width);
std::vector<CoilSegment> &getSegments(); std::vector<CoilSegment> &getSegments();
float getWidth(); float getWidth();
float getRadius(); float getRadius();
void render(); void render();
void fillVBO(float *vertices);
uint32_t fillEBO();
void initGLBuffers(); void initGLBuffers();
}; };

397
src/coil/segment.cpp
View File

@@ -12,10 +12,6 @@
#include <coil/segment.hpp> #include <coil/segment.hpp>
#include <coil/coil.hpp> #include <coil/coil.hpp>
// x, y, z, r, g, b
#define FIELDS_IN_POINT 6
#define DAYS_IN_YEAR (isLeap? 366.0f : 365.0f)
using glm::vec4; using glm::vec4;
using glm::vec3; using glm::vec3;
using glm::mat4; using glm::mat4;
@@ -30,260 +26,239 @@ using std::cout;
using std::cerr; using std::cerr;
CoilSegment::CoilSegment( CoilSegment::CoilSegment(
Coil* coil, Coil* coil,
uint16_t year, uint16_t year,
uint16_t height, uint16_t height,
int shift, int shift,
uint32_t sliceDetalization, uint32_t sliceDetailization
bool isLeap ):
) : coil(coil), year(year),
coil(coil), year(year), height(height), shift(shift),
height(height), shift(shift), sliceDetailization(sliceDetailization),
sliceDetalization(sliceDetalization), isLeap(isLeap) { slicePointsAmount(sliceDetailization + 2),
init(); //evil shit
calculate(); leap(year % 4 == 0? year % 100 == 0? year % 400 == 0 : true : false) {
} init();
// calculate();
}
void CoilSegment::init () { void CoilSegment::init () {
verticesLength = DAYS_IN_YEAR * FIELDS_IN_POINT * (sliceDetalization+2); verticesLength = getDaysAmount() * slicePointsAmount * FIELDS_IN_POINT;
vertices = (float *) calloc(verticesLength, sizeof(float)); vertices = (float *) malloc(verticesLength * sizeof(float));
if (vertices == NULL) { if (vertices == NULL) {
cerr << "Allocation failed" << endl; cerr << "Allocation failed" << endl;
exit(-1); exit(-1);
} }
calculate(); calculate();
// cout << "Initialized CoilSegment"
// << "(year: " << year
// << ", height: " << height
// << ", shift: " << shift
// << ", isLeap: " << isLeap <<")" << endl;
} }
void CoilSegment::printVertices() { void CoilSegment::printVertices() {
for (uint16_t day = 0; day < DAYS_IN_YEAR; day ++) { for (uint16_t day = 0; day < getDaysAmount(); day ++) {
cout << "Day " << day << ", " << cout << "Day " << day << ", " <<
"x: " << vertices[FIELDS_IN_POINT * day + 0] << ", " << "x: " << vertices[FIELDS_IN_POINT * day + 0] << ", " <<
"y: " << vertices[FIELDS_IN_POINT * day + 1] << ", " << "y: " << vertices[FIELDS_IN_POINT * day + 1] << ", " <<
"z: " << vertices[FIELDS_IN_POINT * day + 2] << ", " << "z: " << vertices[FIELDS_IN_POINT * day + 2] << ", " <<
"r: " << vertices[FIELDS_IN_POINT * day + 3] << ", " << "r: " << vertices[FIELDS_IN_POINT * day + 3] << ", " <<
"g: " << vertices[FIELDS_IN_POINT * day + 4] << ", " << "g: " << vertices[FIELDS_IN_POINT * day + 4] << ", " <<
"b: " << vertices[FIELDS_IN_POINT * day + 5] << endl; "b: " << vertices[FIELDS_IN_POINT * day + 5] << endl;
} }
} }
float *CoilSegment::calculateSlice() { float *CoilSegment::calculateSlice() {
uint32_t size = (/*start and end of a slize*/2 + sliceDetalization) * FIELDS_IN_POINT * sizeof(float); uint32_t size = slicePointsAmount * 3 * sizeof(float);
float *slice = (float *)malloc(size); float *slice = (float *)malloc(size);
mat4 transform = mat4(1.); mat4 transform = mat4(1.);
transform = glm::scale( transform = glm::scale(
transform, transform,
vec3( vec3(
coil->getWidth(), coil->getWidth(),
10, 10,
1 1
) )
); );
vec3 point = vec3(cos(0), sin(0), 0); // Start of a slice
// Start of a slice slice[0] = cos(0);
slice[0] = cos(0); slice[1] = sin(0);
slice[1] = sin(0); slice[2] = 0;
slice[2] = 0;
slice[3] = 1;
slice[4] = 1;
slice[5] = 1;
float degreeByPoint = -180. / (sliceDetalization + 1); float degreeByPoint = -180. / (sliceDetailization + 1);
for (uint32_t i = 1; i <= sliceDetalization; i ++) { for (uint32_t i = 1; i <= sliceDetailization; i ++) {
uint32_t offset = FIELDS_IN_POINT * i; uint32_t offset = FIELDS_IN_POINT * i;
slice[offset + 0] = round_to_presicion(cos(radians(degreeByPoint * i)), 5);
slice[offset + 1] = round_to_presicion(sin(radians(degreeByPoint * i)), 5);
slice[offset + 2] = 0;
slice[offset + 3] = 1;
slice[offset + 4] = 1;
slice[offset + 5] = 1;
}
// End of a slice slice[offset + 0] = round_to_precision(cos(radians(degreeByPoint * i)), 5);
uint32_t endIndex = (size / sizeof(float) - FIELDS_IN_POINT); slice[offset + 1] = round_to_precision(sin(radians(degreeByPoint * i)), 5);
slice[endIndex + 0] = round_to_presicion(cos(radians(180.)), 5); slice[offset + 2] = 0;
slice[endIndex + 1] = round_to_presicion(sin(radians(180.)), 5); }
slice[endIndex + 2] = 0;
slice[endIndex + 3] = 1;
slice[endIndex + 4] = 1;
slice[endIndex + 5] = 1;
return slice; // End of a slice
uint32_t endIndex = (size / sizeof(float) - FIELDS_IN_POINT);
slice[endIndex + 0] = round_to_precision(cos(radians(180.)), 5);
slice[endIndex + 1] = round_to_precision(sin(radians(180.)), 5);
slice[endIndex + 2] = 0;
return slice;
} }
void CoilSegment::constructSegment(float *slice) { void CoilSegment::constructSegment(float *slice) {
float degreesPerDay = 360.f / DAYS_IN_YEAR; float degreesPerDay = 360.f / getDaysAmount();
for (uint32_t day = 0; day < DAYS_IN_YEAR; day ++) { for (uint32_t day = 0; day < getDaysAmount(); day ++) {
float daysDegree = day * degreesPerDay; float daysDegree = day * degreesPerDay;
vec3 daysPosition = vec3( vec3 daysPosition = vec3(
cos(radians(daysDegree)) * coil->getRadius(), cos(radians(daysDegree)) * coil->getRadius(),
10* daysDegree/360., height * daysDegree/360. + shift * height,
sin(radians(daysDegree)) * coil->getRadius() sin(radians(daysDegree)) * coil->getRadius()
); );
mat4 transform = mat4(1.); mat4 transform = mat4(1.);
transform = translate( transform = translate(
transform, transform,
daysPosition daysPosition
); );
transform = rotate( transform = rotate(
transform, transform,
-radians(daysDegree), -radians(daysDegree),
vec3( vec3(
0.0, 0.0,
1.0, 1.0,
0.0 0.0
) )
); );
for (uint32_t slicePoint = 0; slicePoint < (2 + sliceDetalization); slicePoint ++) { for (uint32_t slicePoint = 0; slicePoint < slicePointsAmount; slicePoint ++) {
uint32_t slicePointOffset = FIELDS_IN_POINT * slicePoint; uint32_t slicePointOffset = 3 * slicePoint;
vec4 point( vec4 point(
slice[slicePointOffset + 0], slice[slicePointOffset + 0],
slice[slicePointOffset + 1], slice[slicePointOffset + 1],
slice[slicePointOffset + 2], slice[slicePointOffset + 2],
1 1
); );
point = transform * point;
uint64_t currentPointOffset = day * (2+sliceDetalization) * FIELDS_IN_POINT + slicePointOffset;
vertices[currentPointOffset + 0] = point.x;
vertices[currentPointOffset + 1] = point.y;
vertices[currentPointOffset + 2] = point.z;
vertices[currentPointOffset + 3] = 0.5; point = transform * point;
vertices[currentPointOffset + 4] = 0.5; uint64_t currentPointOffset = day * slicePointsAmount * FIELDS_IN_POINT + slicePointOffset*2;
vertices[currentPointOffset + 5] = 0.5; vertices[currentPointOffset + 0] = point.x;
vertices[currentPointOffset + 1] = point.y;
// memcpy( vertices[currentPointOffset + 2] = point.z;
// vertices + currentPointOffset + 3,
// slice + slicePointOffset + 3, vertices[currentPointOffset + 3] = (float)slicePoint / slicePointsAmount;
// 3 vertices[currentPointOffset + 4] = 0;
// ); vertices[currentPointOffset + 5] = 0;
} }
} }
} free(slice);
void CoilSegment::fillVBO() {
// printVertices();
glBufferData(GL_ARRAY_BUFFER, sizeof(float) * verticesLength, vertices, GL_STATIC_DRAW);
} }
uint64_t CoilSegment::fillEBO(uint64_t EBO) { uint64_t CoilSegment::fillEBO(uint64_t EBO) {
uint64_t indicesLength = 6 * (sliceDetalization+2) * DAYS_IN_YEAR; uint64_t indicesLength = 6 * slicePointsAmount * getDaysAmount();
uint64_t currentIndex = 0; uint64_t currentIndex = 0;
uint64_t* indices = (uint64_t*) calloc(indicesLength, sizeof(uint64_t)); uint64_t* indices = (uint64_t*) calloc(indicesLength, sizeof(uint64_t));
for (uint64_t day = 0; day < DAYS_IN_YEAR; day ++) { for (uint64_t day = 0; day < getDaysAmount() - 1; day ++) {
for (uint64_t pointOfSlice = 0; pointOfSlice < (sliceDetalization+2); pointOfSlice ++) { for (uint64_t pointOfSlice = 0; pointOfSlice < slicePointsAmount; pointOfSlice ++) {
// cout << currentIndex << endl; // cout << currentIndex << endl;
uint64_t dayOffset = day * (sliceDetalization+2); uint64_t dayOffset = day * slicePointsAmount;
uint64_t offset = dayOffset + pointOfSlice; uint64_t currentPointIndex = dayOffset + pointOfSlice;
//First triangle
indices[currentIndex] = offset;
currentIndex ++;
indices[currentIndex] = offset + (sliceDetalization+2);
currentIndex ++;
indices[currentIndex] = offset + 1;
currentIndex++;
//Second triangle
if (pointOfSlice % (sliceDetalization+1) == 0 && pointOfSlice != 0) {
indices[currentIndex] = offset - (sliceDetalization+2);
currentIndex++;
indices[currentIndex] = offset + 1;
currentIndex++;
indices[currentIndex] = offset;
} else {
indices[currentIndex] = offset + 1;
currentIndex++;
indices[currentIndex] = offset + (sliceDetalization+3);
currentIndex ++;
indices[currentIndex] = offset + (sliceDetalization+2);
}
currentIndex ++;
}
}
// for (uint64_t i = 0; i < indicesLength; i ++) { //First triangle
// cout << indices[i] << ","; indices[currentIndex] = currentPointIndex;
// } currentIndex ++;
// cout << endl; indices[currentIndex] = currentPointIndex + slicePointsAmount;
// cout << indicesLength << endl; currentIndex ++;
indices[currentIndex] = currentPointIndex + 1;
currentIndex++;
//Second triangle
// if (pointOfSlice % (sliceDetalization+1) == 0 && pointOfSlice != 0) {
if (pointOfSlice == sliceDetailization+1) {
indices[currentIndex] = currentPointIndex - (slicePointsAmount - 1);
currentIndex++;
indices[currentIndex] = currentPointIndex + 1;
currentIndex++;
indices[currentIndex] = currentPointIndex;
} else {
indices[currentIndex] = currentPointIndex + 1;
currentIndex++;
indices[currentIndex] = currentPointIndex + slicePointsAmount + 1;
currentIndex ++;
indices[currentIndex] = currentPointIndex + slicePointsAmount;
}
currentIndex ++;
}
}
if (currentIndex != indicesLength) { // for (uint64_t i = 0; i < indicesLength; i ++) {
cerr << "currentIndex == indicesLength assertion failed" << endl; // cout << indices[i] << ",";
cerr << currentIndex << " " << indicesLength << endl; // }
} // cout << endl;
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO); // cout << indicesLength << endl;
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(unsigned long) * indicesLength, indices, GL_STATIC_DRAW);
free(indices); if (currentIndex != indicesLength) {
return indicesLength; cerr << "currentIndex == indicesLength assertion failed" << endl;
cerr << currentIndex << " " << indicesLength << endl;
}
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(unsigned long) * indicesLength, indices, GL_STATIC_DRAW);
free(indices);
return indicesLength;
} }
// void testEBO(uint64_t *EBO, uint64_t length) {
// for (uint64_t i = 0; i < length; i ++) {
// }
// }
// Sample layout of 2 slices with 3 points. // Sample layout of 2 slices with 3 points.
// |x |y |z |r |g |b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | // |x |y |z |r |g |b | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |
// 0 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 // 0 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
// | point | point | point | point | point | point | // | point | point | point | point | point | point |
// | slice | slice | // | slice | slice |
// //
void CoilSegment::calculate() { void CoilSegment::calculate() {
float *slice = calculateSlice(); float *slice = calculateSlice();
constructSegment(slice);
exportSegmentToCsv();
constructSegment(slice);
} }
float *CoilSegment::getVertices() { return vertices; } float *CoilSegment::getVertices() { return vertices; }
uint64_t CoilSegment::getVerticesLength() { return verticesLength; } uint64_t CoilSegment::getVerticesLength() { return verticesLength; }
uint64_t CoilSegment::getVerticesAmount() { return verticesLength / FIELDS_IN_POINT; }
uint16_t CoilSegment::getYear() { return year; } uint16_t CoilSegment::getYear() { return year; }
void CoilSegment::render() {
}
void CoilSegment::exportSliceToCSV(float *slice) { void CoilSegment::exportSliceToCSV(float *slice) {
cout << "Exporting slice to csv" << endl; cout << "Exporting slice to csv" << endl;
std::ofstream outFile("./slice_export.csv"); std::ofstream outFile("./slice_export.csv");
outFile << "x,y,z" << endl; outFile << "x,y,z" << endl;
for (uint32_t i = 0; i < sliceDetalization+2; i ++) { for (uint32_t i = 0; i < slicePointsAmount; i ++) {
uint32_t offset = FIELDS_IN_POINT * i; uint32_t offset = FIELDS_IN_POINT * i;
outFile outFile
<< slice[offset + 0] << "," << slice[offset + 0] << ","
<< slice[offset + 1] << ",0" << endl; << slice[offset + 1] << ",0" << endl;
} }
} }
void CoilSegment::exportSegmentToCsv() { void CoilSegment::exportSegmentToCsv() {
cout << "Exporting segment to csv" << endl; cout << "Exporting segment to csv" << endl;
std::ofstream outFile("./segment_export.csv"); std::ofstream outFile("./segment_export.csv");
outFile << "x,y,z" << endl; outFile << "x,y,z" << endl;
for (uint16_t day = 0; day < DAYS_IN_YEAR; day ++) { for (uint16_t day = 0; day < getDaysAmount(); day ++) {
uint64_t dayOffset = day * (2+sliceDetalization) * FIELDS_IN_POINT; uint64_t dayOffset = day * slicePointsAmount * FIELDS_IN_POINT;
for (uint32_t point_in_slice = 0; point_in_slice < (2+sliceDetalization); point_in_slice ++) { for (uint32_t point_in_slice = 0; point_in_slice < slicePointsAmount; point_in_slice ++) {
uint32_t sliceOffset = point_in_slice * FIELDS_IN_POINT; uint32_t sliceOffset = point_in_slice * FIELDS_IN_POINT;
outFile << vertices[dayOffset + sliceOffset + 0] << "," outFile << vertices[dayOffset + sliceOffset + 0] << ","
<< vertices[dayOffset + sliceOffset + 1] << "," << vertices[dayOffset + sliceOffset + 1] << ","
<< vertices[dayOffset + sliceOffset + 2] << endl; << vertices[dayOffset + sliceOffset + 2] << endl;
} }
} }
} }
uint16_t CoilSegment::getDaysAmount() { return leap? 366 : 365; }
bool const CoilSegment::isLeap() { return leap; }
uint32_t CoilSegment::getSliceDetailization() { return sliceDetailization; }
uint32_t CoilSegment::getSlicePointsAmount() { return sliceDetailization + 2; }

18
src/coil/segment.hpp
View File

@@ -3,6 +3,9 @@
#include <cstdint> #include <cstdint>
// x, y, z, r, g, b
#define FIELDS_IN_POINT 6
class Coil; class Coil;
class CoilSegment { class CoilSegment {
@@ -11,8 +14,9 @@ class CoilSegment {
uint16_t height; uint16_t height;
// Number of a segments, counting from the central (which is 0) // Number of a segments, counting from the central (which is 0)
int shift; int shift;
uint32_t sliceDetalization; uint32_t sliceDetailization;
bool isLeap; uint32_t slicePointsAmount;
bool leap;
float *vertices; float *vertices;
uint64_t verticesLength; uint64_t verticesLength;
@@ -21,18 +25,22 @@ class CoilSegment {
void constructSegment(float *slice); void constructSegment(float *slice);
public: public:
CoilSegment(Coil* coil, uint16_t year, uint16_t height, int shift, uint32_t sliceDetalization, bool isLeap); CoilSegment(Coil* coil, uint16_t year, uint16_t height, int shift, uint32_t sliceDetalization);
void calculate(); void calculate();
void printVertices(); void printVertices();
float *getVertices(); float *getVertices();
uint64_t getVerticesLength(); uint64_t getVerticesLength();
uint64_t getVerticesAmount();
void printSlice(float *slice); void printSlice(float *slice);
void exportSliceToCSV(float *slice); void exportSliceToCSV(float *slice);
void exportSegmentToCsv(); void exportSegmentToCsv();
void render();
void fillVBO();
uint64_t fillEBO(uint64_t EBO); uint64_t fillEBO(uint64_t EBO);
uint16_t getYear(); uint16_t getYear();
uint16_t getDaysAmount();
bool const isLeap();
uint32_t getSliceDetailization();
uint32_t getSlicePointsAmount();
}; };
#endif // COIL_SEGMENT_HPP #endif // COIL_SEGMENT_HPP

174
src/main.cpp
View File

@@ -9,9 +9,14 @@
#include <glm/gtc/matrix_transform.hpp> #include <glm/gtc/matrix_transform.hpp>
#include <glm/gtc/type_ptr.hpp> #include <glm/gtc/type_ptr.hpp>
#include <coil/coil.hpp> #include <coil/coil.hpp>
#include <coil/segment.hpp> #include <coil/segment.hpp>
#include <utils/utils.hpp> #include <utils/utils.hpp>
#include <camera/camera.hpp>
using std::cerr; using std::cerr;
using std::cout; using std::cout;
@@ -23,18 +28,36 @@ using std::endl;
void framebufferSizeCallback(GLFWwindow *window, int width, int height) { void framebufferSizeCallback(GLFWwindow *window, int width, int height) {
glViewport(10, 10, width-10, height-10); glViewport(10, 10, width-10, height-10);
} }
Camera cam = Camera(glm::vec3(0., 0., 0), glm::vec3(0., 1.,0.),-89, 0, 20, 0.1, CameraType::FREE);
void processInput(GLFWwindow *window) { void processInput(GLFWwindow *window) {
if(glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) { if(glfwGetKey(window, GLFW_KEY_ESCAPE) == GLFW_PRESS) {
glfwSetWindowShouldClose(window, true); glfwSetWindowShouldClose(window, true);
} return;
}
CameraMovement dir;
if (glfwGetKey(window, GLFW_KEY_W) == GLFW_PRESS)
dir = CameraMovement::FORWARD;
if (glfwGetKey(window, GLFW_KEY_S) == GLFW_PRESS)
dir = CameraMovement::BACKWARD;
if (glfwGetKey(window, GLFW_KEY_A) == GLFW_PRESS)
dir = CameraMovement::LEFT;
if (glfwGetKey(window, GLFW_KEY_D) == GLFW_PRESS)
dir = CameraMovement::RIGHT;
cam.processKeyboardInput(dir);
} }
void processMousePosCallback(GLFWwindow *window, double deltaX, double deltaY) {
cam.processMouseInput(window, deltaX, deltaY);
}
int main () { int main () {
Coil coil = Coil(2025, 3, 10, 2, 50, 10);
Coil c = Coil(2025, 1, 5, 50, 10);
srand(time(0)); srand(time(0));
glfwInit(); glfwInit();
@@ -53,6 +76,8 @@ int main () {
glfwMakeContextCurrent(window); glfwMakeContextCurrent(window);
glfwSetFramebufferSizeCallback(window, framebufferSizeCallback); glfwSetFramebufferSizeCallback(window, framebufferSizeCallback);
glfwSetCursorPosCallback(window, processMousePosCallback);
// glfwSetInputMode(window, GLFW_CURSOR, GLFW_CURSOR_CAPTURED);
if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) { if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
cerr << "Failed to initialize GLAD." << endl; cerr << "Failed to initialize GLAD." << endl;
@@ -68,159 +93,30 @@ int main () {
unsigned int projectionLoc = glGetUniformLocation(shaderProgram, "projection"); unsigned int projectionLoc = glGetUniformLocation(shaderProgram, "projection");
glUniformMatrix4fv(projectionLoc, 1, GL_FALSE, glm::value_ptr(projection)); glUniformMatrix4fv(projectionLoc, 1, GL_FALSE, glm::value_ptr(projection));
// glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
c.initGLBuffers(); coil.initGLBuffers();
glEnable(GL_DEPTH_TEST);
// float vertices[] = {
// // positions // texture coords
// 05.5f, 0.5f, 0.0f, 1.0f, 1.0f, // top right
// 0.5f, -0.5f, 0.0f, 1.0f, 0.0f, // bottom right
// -0.5f, -0.5f, 0.0f, 0.0f, 0.0f, // bottom left
// -0.5f, 0.5f, 0.0f, 0.0f, 1.0f // top left
// };
// unsigned int indices[] = {
// 0, 1, 3, // first triangle
// 1, 2, 3 // second triangle
// };
// unsigned int VBO, VAO, EBO;
// glGenVertexArrays(1, &VAO);
// glGenBuffers(1, &VBO);
// glGenBuffers(1, &EBO);
// glBindVertexArray(VAO);
// glBindBuffer(GL_ARRAY_BUFFER, VBO);
// glBufferData(GL_ARRAY_BUFFER, sizeof(vertices), vertices, GL_STATIC_DRAW);
// glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
// glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
// // position attribute
// glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)0);
// glEnableVertexAttribArray(0);
// // texture coord attribute
// glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(float), (void*)(3 * sizeof(float)));
// glEnableVertexAttribArray(1);
while(!glfwWindowShouldClose(window)) { while(!glfwWindowShouldClose(window)) {
processInput(window); processInput(window);
glClearColor(0.2f, 0.3f, 0.3f, 1.0f); glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
glClear(GL_COLOR_BUFFER_BIT); glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
glm::mat4 model = glm::mat4(1.0f); glm::mat4 model = glm::mat4(1.0f);
glm::mat4 view = glm::mat4(1.0f); glm::mat4 view = glm::mat4(1.0f);
model = glm::rotate(model, glm::radians(5.0f), glm::vec3(1.0f, 0.0f, 0.0f)); model = glm::rotate(model, glm::radians(5.0f), glm::vec3(1.0f, 0.0f, 0.0f));
view = glm::translate(view, glm::vec3(0.0f, 0.0f, -89.0f)); view = cam.getViewMatrix();
unsigned int modelLoc = glGetUniformLocation(shaderProgram, "model"); unsigned int modelLoc = glGetUniformLocation(shaderProgram, "model");
unsigned int viewLoc = glGetUniformLocation(shaderProgram, "view"); unsigned int viewLoc = glGetUniformLocation(shaderProgram, "view");
glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model)); glUniformMatrix4fv(modelLoc, 1, GL_FALSE, glm::value_ptr(model));
glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view)); glUniformMatrix4fv(viewLoc, 1, GL_FALSE, glm::value_ptr(view));
c.render(); coil.render();
// glBindVertexArray(VAO);
// glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
glfwSwapBuffers(window); glfwSwapBuffers(window);
glfwPollEvents(); glfwPollEvents();
} }
// CoilSegment cs = CoilSegment(10, 0, false);
// for (auto segment : c.getSegments()) {
// // segment.printVertices();
// }
// cs.printVertices();
gracefulExit(0); gracefulExit(0);
// srand(time(0));
// glfwInit();
// glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
// glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
// glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
// #ifdef __APPLE__
// glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE);
// #endif
// GLFWwindow *window = glfwCreateWindow(800, 600, "TimeCoil", NULL, NULL);
// if (window == NULL) {
// std::cerr << "Failed to create GLFW window." << std::endl;
// gracefulExit(-1);
// }
// glfwMakeContextCurrent(window);
// glfwSetFramebufferSizeCallback(window, framebufferSizeCallback);
// if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
// std::cerr << "Failed to initialize GLAD." << std::endl;
// return -1;
// }
// unsigned int shaderProgram = prepareShaders();
// float *vertices = cs.getVertices();
// unsigned int amountOfVerticies = cs.getVerticesLength();
// std::cout << amountOfVerticies << std::endl;
// // float vertices[] = {
// // -1.0f, -1.0f, 0.0f, 1.0f, 0.0f, 0.0f, // upper left
// // -0.5f, -0.5f, 0.0f, 0.0f, 1.0f, 0.0f, // bottom left
// // 0.5f, 0.5f, 0.0f, 1.0f, 0.0f, 0.0f, // upper right
// // 1.0f, 1.0f, 0.0f, 0.0f, 1.0f, 0.0f // bottom right
// // };
// // unsigned int indices[] = {
// // 1, 2, 3,
// // 1, 2, 0
// // };
// unsigned int VBO, VAO, EBO;
// glGenVertexArrays(1, &VAO);
// glGenBuffers(1, &VBO);
// // glGenBuffers(1, &EBO);
// glBindVertexArray(VAO);
// glBindBuffer(GL_ARRAY_BUFFER, VBO);
// // glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, EBO);
// glBufferData(GL_ARRAY_BUFFER, amountOfVerticies, vertices, GL_STATIC_DRAW);
// // glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(indices), indices, GL_STATIC_DRAW);
// glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*)0);
// glEnableVertexAttribArray(0);
// glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 6 * sizeof(float), (void*) (3 * sizeof(float)));
// glEnableVertexAttribArray(1);
// glBindVertexArray(0);
// while(!glfwWindowShouldClose(window)) {
// processInput(window);
// glClearColor(0.2f, 0.3f, 0.3f, 1.0f);
// glClear(GL_COLOR_BUFFER_BIT);
// glUseProgram(shaderProgram);
// // float time = glfwGetTime();
// // float greenValue = sin(time);
// // int vertexColorLocation = glGetUniformLocation(shaderProgram, "MyColor");
// // glUniform4f(vertexColorLocation, 0, greenValue, 0, 1);
// glBindVertexArray(VAO);
// // updateVertices(vertices);
// glBufferData(GL_ARRAY_BUFFER, amountOfVerticies, vertices, GL_DYNAMIC_DRAW);
// // glDrawElements(GL_TRIANGLES, 6, GL_UNSIGNED_INT, 0);
// glDrawArrays(GL_LINE_STRIP_ADJACENCY, -30, amountOfVerticies);
// glBindVertexArray(0);
// glfwSwapBuffers(window);
// glfwPollEvents();
// }
// glDeleteVertexArrays(1, &VAO);
// glDeleteBuffers(1, &VBO);
// glDeleteProgram(shaderProgram);
// gracefulExit(0);
} }

2
src/utils/utils.cpp
View File

@@ -5,7 +5,7 @@
#include <fstream> #include <fstream>
#include <iostream> #include <iostream>
float round_to_presicion( float value, int precision ) { float round_to_precision( float value, int precision ) {
const int adjustment = pow(10,precision); const int adjustment = pow(10,precision);
return floor( value*(adjustment) + 0.5 )/adjustment; return floor( value*(adjustment) + 0.5 )/adjustment;
} }

2
src/utils/utils.hpp
View File

@@ -3,7 +3,7 @@
#include <cmath> #include <cmath>
#include <string> #include <string>
float round_to_presicion( float value, int precision ); float round_to_precision( float value, int precision );
std::string readFile(std::string path); std::string readFile(std::string path);