start
This commit is contained in:
root
531
obj_viewer_shader.cpp
Normal file
531
obj_viewer_shader.cpp
Normal file
@@ -0,0 +1,531 @@
|
||||
#include <iostream>
|
||||
#include <fstream>
|
||||
#include <vector>
|
||||
#include <string>
|
||||
#include <sstream>
|
||||
#include <cmath>
|
||||
#include <GL/glew.h>
|
||||
#include <GL/glut.h>
|
||||
#include <glm/glm.hpp>
|
||||
#include <glm/gtc/matrix_transform.hpp>
|
||||
#include <glm/gtc/type_ptr.hpp>
|
||||
|
||||
struct Vec3 {
|
||||
float x, y, z;
|
||||
Vec3(float x = 0, float y = 0, float z = 0) : x(x), y(y), z(z) {}
|
||||
};
|
||||
|
||||
struct Face {
|
||||
std::vector<int> vertices;
|
||||
std::vector<int> textures;
|
||||
std::vector<int> normals;
|
||||
};
|
||||
|
||||
class OBJModel {
|
||||
public:
|
||||
std::vector<Vec3> vertices;
|
||||
std::vector<Vec3> normals;
|
||||
std::vector<Vec3> texcoords;
|
||||
std::vector<Face> faces;
|
||||
bool loaded;
|
||||
|
||||
GLuint VAO, VBO, NBO;
|
||||
std::vector<float> vertexData;
|
||||
std::vector<float> normalData;
|
||||
|
||||
OBJModel() : loaded(false), VAO(0), VBO(0), NBO(0) {}
|
||||
|
||||
bool loadOBJ(const std::string& filename) {
|
||||
std::ifstream file(filename);
|
||||
if (!file.is_open()) {
|
||||
std::cout << "Модель '" << filename << "' не найдена!" << std::endl;
|
||||
return false;
|
||||
}
|
||||
|
||||
std::string line;
|
||||
while (std::getline(file, line)) {
|
||||
std::istringstream iss(line);
|
||||
std::string prefix;
|
||||
iss >> prefix;
|
||||
|
||||
if (prefix == "v") {
|
||||
float x, y, z;
|
||||
iss >> x >> y >> z;
|
||||
vertices.push_back(Vec3(x, y, z));
|
||||
}
|
||||
else if (prefix == "vn") {
|
||||
float x, y, z;
|
||||
iss >> x >> y >> z;
|
||||
normals.push_back(Vec3(x, y, z));
|
||||
}
|
||||
else if (prefix == "vt") {
|
||||
float u, v;
|
||||
iss >> u >> v;
|
||||
texcoords.push_back(Vec3(u, v, 0));
|
||||
}
|
||||
else if (prefix == "f") {
|
||||
Face face;
|
||||
std::string vertex;
|
||||
while (iss >> vertex) {
|
||||
std::istringstream vss(vertex);
|
||||
std::string index;
|
||||
int idx = 0;
|
||||
|
||||
while (std::getline(vss, index, '/')) {
|
||||
if (!index.empty()) {
|
||||
int i = std::stoi(index) - 1;
|
||||
if (idx == 0) face.vertices.push_back(i);
|
||||
else if (idx == 1) face.textures.push_back(i);
|
||||
else if (idx == 2) face.normals.push_back(i);
|
||||
}
|
||||
idx++;
|
||||
}
|
||||
}
|
||||
faces.push_back(face);
|
||||
}
|
||||
}
|
||||
|
||||
file.close();
|
||||
loaded = true;
|
||||
std::cout << "Модель загружена успешно!" << std::endl;
|
||||
std::cout << "Вершин: " << vertices.size() << std::endl;
|
||||
std::cout << "Граней: " << faces.size() << std::endl;
|
||||
|
||||
setupBuffers();
|
||||
return true;
|
||||
}
|
||||
|
||||
void setupBuffers() {
|
||||
// Преобразуем грани в массив вершин (триангуляция)
|
||||
for (const auto& face : faces) {
|
||||
// Для граней с 3+ вершинами делаем триангуляцию веером
|
||||
for (size_t i = 1; i < face.vertices.size() - 1; ++i) {
|
||||
// Первая вершина треугольника (общая для всех)
|
||||
int v0 = face.vertices[0];
|
||||
int v1 = face.vertices[i];
|
||||
int v2 = face.vertices[i + 1];
|
||||
|
||||
// Добавляем вершины треугольника
|
||||
for (int vIdx : {v0, v1, v2}) {
|
||||
if (vIdx < vertices.size()) {
|
||||
vertexData.push_back(vertices[vIdx].x);
|
||||
vertexData.push_back(vertices[vIdx].y);
|
||||
vertexData.push_back(vertices[vIdx].z);
|
||||
}
|
||||
}
|
||||
|
||||
// Добавляем нормали для треугольника
|
||||
std::vector<size_t> indices = {0, i, i + 1};
|
||||
for (size_t j : indices) {
|
||||
if (j < face.normals.size() && face.normals[j] < normals.size()) {
|
||||
normalData.push_back(normals[face.normals[j]].x);
|
||||
normalData.push_back(normals[face.normals[j]].y);
|
||||
normalData.push_back(normals[face.normals[j]].z);
|
||||
} else {
|
||||
// Если нормалей нет, вычисляем плоскую нормаль
|
||||
normalData.push_back(0.0f);
|
||||
normalData.push_back(0.0f);
|
||||
normalData.push_back(1.0f);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
glGenVertexArrays(1, &VAO);
|
||||
glGenBuffers(1, &VBO);
|
||||
glGenBuffers(1, &NBO);
|
||||
|
||||
glBindVertexArray(VAO);
|
||||
|
||||
// Вершины
|
||||
glBindBuffer(GL_ARRAY_BUFFER, VBO);
|
||||
glBufferData(GL_ARRAY_BUFFER, vertexData.size() * sizeof(float),
|
||||
vertexData.data(), GL_STATIC_DRAW);
|
||||
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
|
||||
glEnableVertexAttribArray(0);
|
||||
|
||||
// Нормали
|
||||
glBindBuffer(GL_ARRAY_BUFFER, NBO);
|
||||
glBufferData(GL_ARRAY_BUFFER, normalData.size() * sizeof(float),
|
||||
normalData.data(), GL_STATIC_DRAW);
|
||||
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 3 * sizeof(float), (void*)0);
|
||||
glEnableVertexAttribArray(1);
|
||||
|
||||
glBindVertexArray(0);
|
||||
}
|
||||
|
||||
void render() {
|
||||
if (!loaded || VAO == 0) return;
|
||||
|
||||
glBindVertexArray(VAO);
|
||||
glDrawArrays(GL_TRIANGLES, 0, vertexData.size() / 3);
|
||||
glBindVertexArray(0);
|
||||
}
|
||||
|
||||
~OBJModel() {
|
||||
if (VAO) glDeleteVertexArrays(1, &VAO);
|
||||
if (VBO) glDeleteBuffers(1, &VBO);
|
||||
if (NBO) glDeleteBuffers(1, &NBO);
|
||||
}
|
||||
};
|
||||
|
||||
// Функция для загрузки шейдера
|
||||
std::string loadShaderSource(const std::string& filepath) {
|
||||
std::ifstream file(filepath);
|
||||
if (!file.is_open()) {
|
||||
std::cerr << "Не удалось открыть файл шейдера: " << filepath << std::endl;
|
||||
return "";
|
||||
}
|
||||
std::stringstream buffer;
|
||||
buffer << file.rdbuf();
|
||||
return buffer.str();
|
||||
}
|
||||
|
||||
// Компиляция шейдера
|
||||
GLuint compileShader(GLenum type, const std::string& source) {
|
||||
GLuint shader = glCreateShader(type);
|
||||
const char* src = source.c_str();
|
||||
glShaderSource(shader, 1, &src, nullptr);
|
||||
glCompileShader(shader);
|
||||
|
||||
GLint success;
|
||||
glGetShaderiv(shader, GL_COMPILE_STATUS, &success);
|
||||
if (!success) {
|
||||
char infoLog[512];
|
||||
glGetShaderInfoLog(shader, 512, nullptr, infoLog);
|
||||
std::cerr << "Ошибка компиляции шейдера:\n" << infoLog << std::endl;
|
||||
return 0;
|
||||
}
|
||||
return shader;
|
||||
}
|
||||
|
||||
// Создание шейдерной программы
|
||||
GLuint createShaderProgram(const std::string& vertexPath, const std::string& fragmentPath) {
|
||||
std::string vertexSource = loadShaderSource(vertexPath);
|
||||
std::string fragmentSource = loadShaderSource(fragmentPath);
|
||||
|
||||
if (vertexSource.empty() || fragmentSource.empty()) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
GLuint vertexShader = compileShader(GL_VERTEX_SHADER, vertexSource);
|
||||
GLuint fragmentShader = compileShader(GL_FRAGMENT_SHADER, fragmentSource);
|
||||
|
||||
if (!vertexShader || !fragmentShader) {
|
||||
return 0;
|
||||
}
|
||||
|
||||
GLuint program = glCreateProgram();
|
||||
glAttachShader(program, vertexShader);
|
||||
glAttachShader(program, fragmentShader);
|
||||
glLinkProgram(program);
|
||||
|
||||
GLint success;
|
||||
glGetProgramiv(program, GL_LINK_STATUS, &success);
|
||||
if (!success) {
|
||||
char infoLog[512];
|
||||
glGetProgramInfoLog(program, 512, nullptr, infoLog);
|
||||
std::cerr << "Ошибка линковки шейдерной программы:\n" << infoLog << std::endl;
|
||||
return 0;
|
||||
}
|
||||
|
||||
glDeleteShader(vertexShader);
|
||||
glDeleteShader(fragmentShader);
|
||||
|
||||
return program;
|
||||
}
|
||||
|
||||
// Глобальные переменные
|
||||
OBJModel model;
|
||||
GLuint shaderProgram;
|
||||
std::vector<GLuint> shaderPrograms;
|
||||
std::vector<std::string> shaderNames;
|
||||
int currentShader = 0;
|
||||
float rotationX = 0.0f;
|
||||
float rotationY = 0.0f;
|
||||
float zoom = 5.0f;
|
||||
int lastMouseX = 0;
|
||||
int lastMouseY = 0;
|
||||
bool mouseLeftDown = false;
|
||||
bool mouseRightDown = false;
|
||||
bool showWireframe = false;
|
||||
|
||||
// Параметры для шейдера неба
|
||||
float skyHeight = 5000.0f;
|
||||
float sunElevation = 0.5f;
|
||||
float sunIntensity = 0.8f;
|
||||
|
||||
void display() {
|
||||
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
|
||||
|
||||
// Используем текущий шейдер
|
||||
GLuint activeShader = shaderPrograms[currentShader];
|
||||
glUseProgram(activeShader);
|
||||
|
||||
// Матрицы трансформации
|
||||
glm::mat4 model_matrix = glm::mat4(1.0f);
|
||||
model_matrix = glm::rotate(model_matrix, glm::radians(rotationX), glm::vec3(1.0f, 0.0f, 0.0f));
|
||||
model_matrix = glm::rotate(model_matrix, glm::radians(rotationY), glm::vec3(0.0f, 1.0f, 0.0f));
|
||||
|
||||
glm::mat4 view = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, -zoom));
|
||||
glm::mat4 projection = glm::perspective(glm::radians(45.0f), 800.0f / 600.0f, 0.1f, 100.0f);
|
||||
|
||||
// Передаем матрицы в шейдер
|
||||
glUniformMatrix4fv(glGetUniformLocation(activeShader, "model"), 1, GL_FALSE, glm::value_ptr(model_matrix));
|
||||
glUniformMatrix4fv(glGetUniformLocation(activeShader, "view"), 1, GL_FALSE, glm::value_ptr(view));
|
||||
glUniformMatrix4fv(glGetUniformLocation(activeShader, "projection"), 1, GL_FALSE, glm::value_ptr(projection));
|
||||
|
||||
// Параметры освещения (не все шейдеры их используют, но это не проблема)
|
||||
glm::vec3 lightPos(5.0f, 5.0f, 5.0f);
|
||||
glm::vec3 viewPos(0.0f, 0.0f, zoom);
|
||||
glm::vec3 lightColor(1.0f, 1.0f, 1.0f);
|
||||
glm::vec3 objectColor(0.8f, 0.8f, 0.8f);
|
||||
|
||||
glUniform3fv(glGetUniformLocation(activeShader, "lightPos"), 1, glm::value_ptr(lightPos));
|
||||
glUniform3fv(glGetUniformLocation(activeShader, "viewPos"), 1, glm::value_ptr(viewPos));
|
||||
glUniform3fv(glGetUniformLocation(activeShader, "lightColor"), 1, glm::value_ptr(lightColor));
|
||||
glUniform3fv(glGetUniformLocation(activeShader, "objectColor"), 1, glm::value_ptr(objectColor));
|
||||
|
||||
// Параметры для шейдера неба
|
||||
glUniform1f(glGetUniformLocation(activeShader, "height"), skyHeight);
|
||||
glUniform1f(glGetUniformLocation(activeShader, "sunElevation"), sunElevation);
|
||||
glUniform1f(glGetUniformLocation(activeShader, "sunIntensity"), sunIntensity);
|
||||
|
||||
// Wireframe режим
|
||||
if (showWireframe) {
|
||||
glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);
|
||||
} else {
|
||||
glPolygonMode(GL_FRONT_AND_BACK, GL_FILL);
|
||||
}
|
||||
|
||||
model.render();
|
||||
|
||||
glutSwapBuffers();
|
||||
}
|
||||
|
||||
void reshape(int w, int h) {
|
||||
glViewport(0, 0, w, h);
|
||||
}
|
||||
|
||||
void mouse(int button, int state, int x, int y) {
|
||||
if (button == GLUT_LEFT_BUTTON) {
|
||||
mouseLeftDown = (state == GLUT_DOWN);
|
||||
lastMouseX = x;
|
||||
lastMouseY = y;
|
||||
}
|
||||
else if (button == GLUT_RIGHT_BUTTON) {
|
||||
mouseRightDown = (state == GLUT_DOWN);
|
||||
lastMouseY = y;
|
||||
}
|
||||
}
|
||||
|
||||
void mouseMotion(int x, int y) {
|
||||
if (mouseLeftDown) {
|
||||
rotationY += (x - lastMouseX) * 0.5f;
|
||||
rotationX += (y - lastMouseY) * 0.5f;
|
||||
lastMouseX = x;
|
||||
lastMouseY = y;
|
||||
glutPostRedisplay();
|
||||
}
|
||||
else if (mouseRightDown) {
|
||||
zoom += (y - lastMouseY) * 0.05f;
|
||||
if (zoom < 1.0f) zoom = 1.0f;
|
||||
lastMouseY = y;
|
||||
glutPostRedisplay();
|
||||
}
|
||||
}
|
||||
|
||||
void printSkyColor() {
|
||||
// Константы - цвета неба
|
||||
glm::vec3 C_strato = glm::vec3(0x05, 0x0F, 0x1F) / 255.0f;
|
||||
glm::vec3 C_sea = glm::vec3(0x87, 0xBD, 0xFF) / 255.0f;
|
||||
glm::vec3 C_warm = glm::vec3(0xFF, 0xF2, 0xD9) / 255.0f;
|
||||
glm::vec3 C_sunset = glm::vec3(0xFF, 0x8C, 0x4D) / 255.0f;
|
||||
|
||||
// 1. Зависимость от высоты
|
||||
float H = 8000.0f;
|
||||
float t = glm::clamp(expf(-skyHeight / H), 0.0f, 1.0f);
|
||||
glm::vec3 C_base = glm::mix(C_strato, C_sea, t);
|
||||
|
||||
// 2. Параметры солнца
|
||||
float d = glm::smoothstep(0.0f, 0.6f, sunElevation);
|
||||
float s = glm::clamp(sunIntensity, 0.0f, 1.0f);
|
||||
|
||||
// 3. Тёплая добавка
|
||||
glm::vec3 C_tint = glm::mix(C_sunset, C_warm, d);
|
||||
float alpha = 0.6f * s * (1.0f - d) * t;
|
||||
|
||||
// 4. Итоговый цвет
|
||||
glm::vec3 C_lit = C_base * (0.55f + 0.45f * s * d) + alpha * C_tint;
|
||||
glm::vec3 C_out = glm::clamp(C_lit, 0.0f, 1.0f);
|
||||
|
||||
std::cout << "\n=== ЦВЕТ НЕБА ===" << std::endl;
|
||||
std::cout << "Параметры:" << std::endl;
|
||||
std::cout << " height: " << skyHeight << std::endl;
|
||||
std::cout << " sunElevation: " << sunElevation << std::endl;
|
||||
std::cout << " sunIntensity: " << sunIntensity << std::endl;
|
||||
std::cout << "Результат (RGB):" << std::endl;
|
||||
printf(" %.2f %.2f %.2f\n", C_out.r, C_out.g, C_out.b);
|
||||
}
|
||||
|
||||
void keyboard(unsigned char key, int x, int y) {
|
||||
bool needUpdate = false;
|
||||
|
||||
if (key == 27) { // ESC
|
||||
exit(0);
|
||||
}
|
||||
else if (key == '1' || key == '2' || key == '3' || key == '4' || key == '5') {
|
||||
int shader = key - '1';
|
||||
if (shader < shaderPrograms.size()) {
|
||||
currentShader = shader;
|
||||
std::cout << "Активирован шейдер: " << shaderNames[currentShader] << std::endl;
|
||||
if (currentShader == 4) { // Sky shader
|
||||
printSkyColor();
|
||||
}
|
||||
glutPostRedisplay();
|
||||
}
|
||||
}
|
||||
else if (key == 'w' || key == 'W') {
|
||||
showWireframe = !showWireframe;
|
||||
std::cout << "Wireframe: " << (showWireframe ? "ВКЛ" : "ВЫКЛ") << std::endl;
|
||||
glutPostRedisplay();
|
||||
}
|
||||
else if (key == 'p' || key == 'P') {
|
||||
printSkyColor();
|
||||
}
|
||||
// Управление высотой
|
||||
else if (key == 'h') {
|
||||
skyHeight -= 500.0f;
|
||||
if (skyHeight < 0) skyHeight = 0;
|
||||
needUpdate = true;
|
||||
}
|
||||
else if (key == 'H') {
|
||||
skyHeight += 500.0f;
|
||||
needUpdate = true;
|
||||
}
|
||||
// Управление углом солнца
|
||||
else if (key == 'e') {
|
||||
sunElevation -= 0.05f;
|
||||
if (sunElevation < 0) sunElevation = 0;
|
||||
needUpdate = true;
|
||||
}
|
||||
else if (key == 'E') {
|
||||
sunElevation += 0.05f;
|
||||
needUpdate = true;
|
||||
}
|
||||
// Управление интенсивностью
|
||||
else if (key == 'i') {
|
||||
sunIntensity -= 0.05f;
|
||||
if (sunIntensity < 0) sunIntensity = 0;
|
||||
needUpdate = true;
|
||||
}
|
||||
else if (key == 'I') {
|
||||
sunIntensity += 0.05f;
|
||||
if (sunIntensity > 1.0f) sunIntensity = 1.0f;
|
||||
needUpdate = true;
|
||||
}
|
||||
|
||||
if (needUpdate) {
|
||||
printSkyColor();
|
||||
glutPostRedisplay();
|
||||
}
|
||||
}
|
||||
|
||||
void init() {
|
||||
glewExperimental = GL_TRUE;
|
||||
GLenum err = glewInit();
|
||||
if (err != GLEW_OK) {
|
||||
std::cerr << "Ошибка инициализации GLEW: " << glewGetErrorString(err) << std::endl;
|
||||
exit(1);
|
||||
}
|
||||
|
||||
glEnable(GL_DEPTH_TEST);
|
||||
glClearColor(0.1f, 0.1f, 0.15f, 1.0f);
|
||||
|
||||
// Загрузка всех шейдеров
|
||||
struct ShaderPair {
|
||||
std::string name;
|
||||
std::string vertex;
|
||||
std::string fragment;
|
||||
};
|
||||
|
||||
std::vector<ShaderPair> shaders = {
|
||||
{"Phong (освещение)", "vertex_shader.glsl", "fragment_shader.glsl"},
|
||||
{"Toon (мультяшный)", "vertex_shader.glsl", "toon_fragment.glsl"},
|
||||
{"Normal (нормали)", "vertex_shader.glsl", "normal_fragment.glsl"},
|
||||
{"Wireframe Style", "vertex_shader.glsl", "wireframe_fragment.glsl"},
|
||||
{"Sky (небо)", "sky_vertex.glsl", "sky.frag"}
|
||||
};
|
||||
|
||||
for (const auto& shader : shaders) {
|
||||
GLuint program = createShaderProgram(shader.vertex, shader.fragment);
|
||||
if (program) {
|
||||
shaderPrograms.push_back(program);
|
||||
shaderNames.push_back(shader.name);
|
||||
std::cout << "✓ Загружен: " << shader.name << std::endl;
|
||||
} else {
|
||||
std::cout << "✗ Ошибка: " << shader.name << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
if (shaderPrograms.empty()) {
|
||||
std::cerr << "Не удалось загрузить ни один шейдер!" << std::endl;
|
||||
exit(1);
|
||||
}
|
||||
|
||||
std::cout << "\nДоступно шейдеров: " << shaderPrograms.size() << std::endl;
|
||||
}
|
||||
|
||||
int main(int argc, char** argv) {
|
||||
std::string filename;
|
||||
|
||||
if (argc > 1) {
|
||||
filename = argv[1];
|
||||
} else {
|
||||
std::cout << "Введите путь к OBJ файлу: ";
|
||||
std::getline(std::cin, filename);
|
||||
}
|
||||
|
||||
// Инициализация GLUT
|
||||
glutInit(&argc, argv);
|
||||
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_DEPTH);
|
||||
glutInitWindowSize(800, 600);
|
||||
glutCreateWindow("OBJ Viewer с шейдерами - Используйте мышь для вращения");
|
||||
|
||||
init();
|
||||
|
||||
// Загрузка модели
|
||||
if (!model.loadOBJ(filename)) {
|
||||
std::cout << "Не удалось загрузить модель." << std::endl;
|
||||
return 1;
|
||||
}
|
||||
|
||||
glutDisplayFunc(display);
|
||||
glutReshapeFunc(reshape);
|
||||
glutMouseFunc(mouse);
|
||||
glutMotionFunc(mouseMotion);
|
||||
glutKeyboardFunc(keyboard);
|
||||
|
||||
std::cout << "\n=== УПРАВЛЕНИЕ ===" << std::endl;
|
||||
std::cout << "Мышь:" << std::endl;
|
||||
std::cout << " - Левая кнопка: вращение модели" << std::endl;
|
||||
std::cout << " - Правая кнопка: приближение/отдаление" << std::endl;
|
||||
std::cout << "\nШейдеры:" << std::endl;
|
||||
std::cout << " - 1: Phong (классическое освещение)" << std::endl;
|
||||
std::cout << " - 2: Toon (мультяшный)" << std::endl;
|
||||
std::cout << " - 3: Normal (нормали)" << std::endl;
|
||||
std::cout << " - 4: Wireframe" << std::endl;
|
||||
std::cout << " - 5: Sky (небо)" << std::endl;
|
||||
std::cout << "\nПараметры неба (шейдер Sky):" << std::endl;
|
||||
std::cout << " - h/H: уменьшить/увеличить высоту" << std::endl;
|
||||
std::cout << " - e/E: уменьшить/увеличить угол солнца" << std::endl;
|
||||
std::cout << " - i/I: уменьшить/увеличить интенсивность" << std::endl;
|
||||
std::cout << " - P: вывести цвет неба в консоль" << std::endl;
|
||||
std::cout << "\nПрочее:" << std::endl;
|
||||
std::cout << " - W: каркасный режим" << std::endl;
|
||||
std::cout << " - ESC: выход" << std::endl;
|
||||
std::cout << "\nТекущий шейдер: " << shaderNames[currentShader] << std::endl;
|
||||
|
||||
glutMainLoop();
|
||||
return 0;
|
||||
}
|
||||
Reference in New Issue
Block a user