Почему я не могу загрузить файлы obj со множеством граней и вершин? [закрыто] ⇐ C++

[Anonymous]

Наименьший объект, который он принимает, составляет около 20 граней в объекте obj1, затем он помечает индекс вектора за пределами диапазона, затем другие объекты принимают любое количество граней, но загружают только то количество граней, которое имеет объект 1
Я пытался уменьшить объекты, но они уже не выглядят хорошо, все похожи на квадратную сферу.
Вот код:
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include
#include "Objeto.h"

using namespace std;

GLFWwindow* window;
Objeto obj1, obj2, obj3, obj4;

struct Vector {
float x, y, z;

Vector operator+(const Vector& v) const {
return { x + v.x, y + v.y, z + v.z };
}
Vector operator-(const Vector& v) const {
return { x - v.x, y - v.y, z - v.z };
}

Vector operator*(float scalar) const {
return { x * scalar, y * scalar, z * scalar };
}

float dot(const Vector& v) const {
return x * v.x + y * v.y + z * v.z;
}

Vector cross(const Vector& v) const {
return {
y * v.z - z * v.y,
z * v.x - x * v.z,
x * v.y - y * v.x
};
}

Vector normalize() const {
float length = sqrt(x * x + y * y + z * z);
return { x / length, y / length, z / length };
}
};

struct CurvaBezier {
Vector p1, p2, p3, p4;
float fuerza;
};

struct Vector3 {
float x, y, z;

Vector3(float x = 0, float y = 0, float z = 0) : x(x), y(y), z(z) {}

Vector3 normalize() const {
float magnitude = std::sqrt(x * x + y * y + z * z);
if (magnitude == 0) {
return Vector3(0, 0, 0);
}
return Vector3(x / magnitude, y / magnitude, z / magnitude);
}

static Vector3 cross(const Vector3& a, const Vector3& b) {
return Vector3(
a.y * b.z - a.z * b.y,
a.z * b.x - a.x * b.z,
a.x * b.y - a.y * b.x
);
}

static float dot(const Vector3& a, const Vector3& b) {
return a.x * b.x + a.y * b.y + a.z * b.z;
}

friend Vector3 operator-(const Vector3& a, const Vector3& b) {
return Vector3(a.x - b.x, a.y - b.y, a.z - b.z);
}

Vector3 operator*(float scalar) const {
return Vector3(x * scalar, y * scalar, z * scalar);
}

Vector3 operator/(float scalar) const {
if (scalar == 0) throw std::runtime_error("Division by zero");
return Vector3(x / scalar, y / scalar, z / scalar);
}

float magnitude() const {
return std::sqrt(x * x + y * y + z * z);
}

Vector3 operator-() const {
return Vector3(-x, -y, -z);
}

bool operator==(const Vector3& other) const {
return x == other.x && y == other.y && z == other.z;
}
};

bool rotateX = false;
bool rotateY = false;
bool rotateZ = false;
float angleX = 0.0f;
float angleY = 0.0f;
float angleZ = 0.0f;

float cameraAngleX = 0.0f;
float cameraAngleY = 0.0f;
long double cameraDistance = 0.000000000000000000001;
float scaleFactor = 0.06f;

double lastX = 400, lastY = 300;
bool firstMouse = true;

int frameCount = 0;
double previousTime = 0.0;
double fps = 0.0;

float fuerzaInicial = 10.0f;
float angulo_lanzamiento = 10.0f;

int colorAmbienteEstado = 0; // 0: Blanco, 1: Rojo, 2: Verde, 3:Azul
int tipo_sombreado = 0; //0 flat, 1 goureaud, 2 nada
bool luz1 = true;
bool luz2 = true;
bool luz3 = true;

std::vector curvas;
float t = 0.0f;
float velocidad = 0.00095f;
float perdidaEnergia = 0.75f;

void inicializarCurvas() {
float radianes = angulo_lanzamiento * (3.14159265 / 180.0f);
CurvaBezier curvaInicial = { {0.0f, 0.0f, 0.0f}, {0.0f, 3.0f + fuerzaInicial * radianes, 1.0f}, {0.0f, 3.0f, 3.0f}, {0.0f, 0.0f, 4.0f}, fuerzaInicial };
curvas.push_back(curvaInicial);
}

void generarNuevaCurva(Vector posicionFinal, float fuerzaAnterior) {
float nuevaFuerza = fuerzaAnterior * perdidaEnergia;
float radianes = angulo_lanzamiento * (3.14159265 / 180.0f);

Vector p1 = posicionFinal;
Vector p2 = { p1.x, p1.y + nuevaFuerza * radianes, p1.z + nuevaFuerza * 0.5f };
Vector p3 = { p2.x, p2.y + nuevaFuerza * 0.3f, p2.z + nuevaFuerza * 0.5f }; Vector p4 = { p3.x, 0.0f, p3.z + nuevaFuerza * 0.2f };

curvas.push_back({ p1, p2, p3, p4, nuevaFuerza });
}

Vector Bezier(Vector p0, Vector p1, Vector p2, Vector p3, float t) {
Vector result;
float u = 1 - t;
result.x = u * u * u * p0.x + 3 * u * u * t * p1.x + 3 * u * t * t * p2.x + t * t * t * p3.x;
result.y = u * u * u * p0.y + 3 * u * u * t * p1.y + 3 * u * t * t * p2.y + t * t * t * p3.y;
result.z = u * u * u * p0.z + 3 * u * u * t * p1.z + 3 * u * t * t * p2.z + t * t * t * p3.z;
return result;
}

Vector calcularIluminacion(Vector punto, Vector normal, Vector luzPos1, bool luz1,
Vector luzPos2, bool luz2, Vector luzPos3, bool luz3,
Vector camPos, Vector colorAmbiente, Vector colorDifuso,
Vector colorEspecular, float shininess) {
Vector iluminacionAmbiente = colorAmbiente;

Vector iluminacionTotal = iluminacionAmbiente;

if (luz1) {
Vector luzDir1 = (luzPos1 - punto).normalize();
float dotNL1 = fmax(0.0f, normal.dot(luzDir1));
Vector difusa1 = colorDifuso * dotNL1;

Vector viewDir1 = (camPos - punto).normalize();
Vector reflectDir1 = (normal * (2.0f * dotNL1) - luzDir1).normalize();
float spec1 = pow(fmax(0.0f, viewDir1.dot(reflectDir1)), shininess);
Vector especular1 = colorEspecular * spec1;

iluminacionTotal = iluminacionTotal + difusa1 + especular1;
}

if (luz2) {
Vector luzDir2 = (luzPos2 - punto).normalize();
float dotNL2 = fmax(0.0f, normal.dot(luzDir2));
Vector difusa2 = colorDifuso * dotNL2;

Vector viewDir2 = (camPos - punto).normalize();
Vector reflectDir2 = (normal * (2.0f * dotNL2) - luzDir2).normalize();
float spec2 = pow(fmax(0.0f, viewDir2.dot(reflectDir2)), shininess);
Vector especular2 = colorEspecular * spec2;

iluminacionTotal = iluminacionTotal + difusa2 + especular2;
}

if (luz3) {
Vector luzDir3 = (luzPos3 - punto).normalize();
float dotNL3 = fmax(0.0f, normal.dot(luzDir3));
Vector difusa3 = colorDifuso * dotNL3;

Vector viewDir3 = (camPos - punto).normalize();
Vector reflectDir3 = (normal * (2.0f * dotNL3) - luzDir3).normalize();
float spec3 = pow(fmax(0.0f, viewDir3.dot(reflectDir3)), shininess);
Vector especular3 = colorEspecular * spec3;

iluminacionTotal = iluminacionTotal + difusa3 + especular3;
}

return iluminacionTotal;
}

Vector calcularNormal(Vertice v1, Vertice v2, Vertice v3) {
Vector u = { v2.GET_pos_x() - v1.GET_pos_x(), v2.GET_pos_y() - v1.GET_pos_y(), v2.GET_pos_z() - v1.GET_pos_z() };
Vector v = { v3.GET_pos_x() - v1.GET_pos_x(), v3.GET_pos_y() - v1.GET_pos_y(), v3.GET_pos_z() - v1.GET_pos_z() };
return u.cross(v).normalize();
}

void drawFPS() {
string fpsText = "FPS: " + to_string(static_cast(fps));

glMatrixMode(GL_PROJECTION);
glPushMatrix();
glLoadIdentity();
gluOrtho2D(0, 800, 0, 600);

glMatrixMode(GL_MODELVIEW);
glPushMatrix();
glLoadIdentity();

glColor3f(0.0f, 1.0f, 0.0f);

int textWidth = fpsText.length() * 9;
glRasterPos2i(800 - textWidth - 10, 580);

for (char c : fpsText) {
glutBitmapCharacter(GLUT_BITMAP_HELVETICA_18, c);
}

glPopMatrix();
glMatrixMode(GL_PROJECTION);
glPopMatrix();
glMatrixMode(GL_MODELVIEW);
}

void key_callback(GLFWwindow* window, int key, int scancode, int action, int mods) {
if (action == GLFW_PRESS || action == GLFW_REPEAT) {
if (key == GLFW_KEY_W) {
scaleFactor += 0.001f;
}
if (key == GLFW_KEY_S) {
scaleFactor -= 0.001f;
}
if (key == GLFW_KEY_A) {
cameraAngleY -= 0.2f;
}
if (key == GLFW_KEY_D) {
cameraAngleY += 0.2f;
}
if (key == GLFW_KEY_Q) {
cameraAngleX -= 0.2f;
}
if (key == GLFW_KEY_E) {
cameraAngleX += 0.2f;
}
if (key == GLFW_KEY_X) {
rotateX = !rotateX;
}
if (key == GLFW_KEY_Y) {
rotateY = !rotateY;
}
if (key == GLFW_KEY_Z) {
rotateZ = !rotateZ;
}
if (key == GLFW_KEY_R) {
colorAmbienteEstado = (colorAmbienteEstado + 1) % 4;
}
if (key == GLFW_KEY_L) {
tipo_sombreado = (tipo_sombreado + 1) % 3;
}
if (key == GLFW_KEY_1) {
luz1 = !luz1;
}
if (key == GLFW_KEY_2) {
luz2 = !luz2;
}
if (key == GLFW_KEY_3) {
luz3 = !luz3;
}
}
}

void cursor_position_callback(GLFWwindow* window, double xpos, double ypos) {
if (firstMouse) {
lastX = xpos;
lastY = ypos;
firstMouse = false;
}

double xoffset = xpos - lastX;
double yoffset = lastY - ypos;

lastX = xpos;
lastY = ypos;

const float sensitivity = 0.1f;
xoffset *= sensitivity;
yoffset *= sensitivity;

cameraAngleY += static_cast(xoffset);
cameraAngleX += static_cast(yoffset);

if (cameraAngleX > 89.0f) cameraAngleX = 89.0f;
if (cameraAngleX < -89.0f) cameraAngleX = -89.0f;
}

Objeto open_obj(const char* archivo) {
Objeto objeto;
ifstream file(archivo);
if (!file.is_open()) {
cerr > vx >> vy >> vz;
Vertice vertice;
vertice.SET_pos_x(vx);
vertice.SET_pos_y(vy);
vertice.SET_pos_z(vz);
objeto.vertices.push_back(vertice);
cout = 0 && index_v1 < objeto.vertices.size() && index_v2 >= 0 && index_v2 < objeto.vertices.size() && index_v3 >= 0 && index_v3 < objeto.vertices.size()) {
Cara cara(index_v1, index_v2, index_v3, 1.0f, 0.0f, 0.0f);
objeto.caras.push_back(cara);
cout

Подробнее здесь: https://stackoverflow.com/questions/792 ... d-vertices