Question

Намалювати правильну шестикутну призму в Open gl, C++. Не плоску

Answer 1

Відповідь:

Пояснення:

Answer 2

Ответ:

Может мой ответ удалят, так как он неверный но opengl очень сложная штука и потратив 2 часа с помощью чатджпт и интернета я не смог добится ожидаемого результата, но тем не менее это лучше чем ничего

#include <stdio.h>

#include <iostream>

#include <SFML/System.hpp>

#include <SFML/Graphics.hpp>

#include <SFML/OpenGL.hpp>

#include "hexagonal_prism_renderer.hpp"

int main(int argc, char *argv[])

{

sf::RenderWindow window(sf::VideoMode::getDesktopMode(), "Hello SFML OpenGL ES 1.1");

sf::View view = window.getDefaultView();

sf::Clock clock;

hexagonal_prism_init();

while (window.isOpen())

{

sf::Event event;

while (window.pollEvent(event))

{

if (event.type == sf::Event::Resized)

{

view.setSize(event.size.width, event.size.height);

view.setCenter(event.size.width / 2, event.size.height / 2);

window.setView(view);

}

}

hexagonal_prism_render(clock.getElapsedTime().asMilliseconds());

window.display();

}

std::cin.get(); // Wait for a key press

return 0;

}

#include "hexagonal_prism_renderer.hpp"

#include <math.h>

#if defined(GLES2)

#include <GLES2/gl2.h>

#elif defined(GLES1)

#include <GLES/gl.h>

#else

#error Wrong GLES version selected (or none)

#endif

#ifdef GLES2

const char *VERTEX_SHADER =

"attribute vec4 position;\n"

"attribute vec4 color;\n"

"varying vec4 vcolor;\n"

"void main()\n"

"{\n"

" gl_Position = vec4(position.xyz, 1.0);\n"

" vcolor = color;\n"

"}";

const char *FRAGMENT_SHADER =

"precision mediump float;\n"

"varying vec4 vcolor;\n"

"void main()\n"

"{\n"

" gl_FragColor = vec4(vcolor.xyz, 1.0);\n"

"}";

#endif

static GLfloat topVertex[3] = {0.0f, 0.5f, 0.0f};

static GLfloat bottomVertex[3] = {0.0f, -0.5f, 0.0f};

static GLfloat sideVertices[18]; // 6 vertices for each side (3 sides)

static GLfloat colors[24] = {};

void hexagonal_prism_init()

{

#ifdef GLES2

GLuint vertex = glCreateShader(GL_VERTEX_SHADER);

glShaderSource(vertex, 1, &VERTEX_SHADER, NULL);

glCompileShader(vertex);

GLuint fragment = glCreateShader(GL_FRAGMENT_SHADER);

glShaderSource(fragment, 1, &FRAGMENT_SHADER, NULL);

glCompileShader(fragment);

GLint success = 0;

glGetShaderiv(vertex, GL_COMPILE_STATUS, &success);

if (!success) {

// Handle compilation error

char infoLog[512];

glGetShaderInfoLog(vertex, 512, NULL, infoLog);

printf("Vertex shader compilation failed: %s\n", infoLog);

}

success = 0;

glGetShaderiv(fragment, GL_COMPILE_STATUS, &success);

if (!success) {

// Handle compilation error

char infoLog[512];

glGetShaderInfoLog(fragment, 512, NULL, infoLog);

printf("Fragment shader compilation failed: %s\n", infoLog);

}

GLuint program = glCreateProgram();

glAttachShader(program, vertex);

glAttachShader(program, fragment);

glLinkProgram(program);

glUseProgram(program);

GLint position = glGetAttribLocation(program, "position");

glEnableVertexAttribArray(position);

glVertexAttribPointer(position, 3, GL_FLOAT, GL_FALSE, 0, topVertex);

GLint color = glGetAttribLocation(program, "color");

glEnableVertexAttribArray(color);

glVertexAttribPointer(color, 4, GL_FLOAT, GL_FALSE, 0, colors);

#endif

}

void hexagonal_prism_render(double timemillis)

{

// Animate colors for the top and bottom vertices

for (int i = 0; i < 3; i++)

{

colors[i * 4 + 0] = sin(i * M_PI * 2 / 3 + timemillis / 1000) / 2 + 0.5f;

colors[i * 4 + 1] = sin((i + 1) * M_PI * 2 / 3 + timemillis / 1000) / 2 + 0.5f;

colors[i * 4 + 2] = sin((i + 2) * M_PI * 2 / 3 + timemillis / 1000) / 2 + 0.5f;

colors[i * 4 + 3] = 1.0f;

}

// Animate colors for the side vertices

for (int i = 0; i < 18; i += 6)

{

colors[i + 3] = sin(i / 6 * M_PI * 2 / 3 + timemillis / 1000) / 2 + 0.5f;

colors[i + 4] = sin((i / 6 + 1) * M_PI * 2 / 3 + timemillis / 1000) / 2 + 0.5f;

colors[i + 5] = sin((i / 6 + 2) * M_PI * 2 / 3 + timemillis / 1000) / 2 + 0.5f;

}

// Clear screen

glClearColor(0.0f, 0.0f, 0.0f, 1.0f);

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

#ifdef GLES1

glEnableClientState(GL_VERTEX_ARRAY);

glEnableClientState(GL_COLOR_ARRAY);

glVertexPointer(3, GL_FLOAT, 0, topVertex);

glColorPointer(4, GL_FLOAT, 0, colors);

#endif

// Draw the top and bottom

glDrawArrays(GL_TRIANGLE_FAN, 0, 3); // Top

glDrawArrays(GL_TRIANGLE_FAN, 3, 3); // Bottom

// Draw the sides

for (int i = 0; i < 3; i++)

{

glDrawArrays(GL_TRIANGLE_STRIP, 6 + i * 6, 6); // Sides

}

}

Answer 3

Для того чтобы нарисовать правильную шестиугольную призму в OpenGL с использованием C++, вам потребуется использовать функции и методы OpenGL для создания и отображения геометрических фигур.

Шаг 1: Инициализация окна и контекста OpenGL

Первым шагом является инициализация окна и контекста OpenGL. Вы можете использовать библиотеку GLFW для создания окна и контекста OpenGL. Вот пример кода для инициализации окна:

#include

int main() {
    // Инициализация GLFW
    if (!glfwInit()) {
        return -1;
    }

// Создание окна
    GLFWwindow* window = glfwCreateWindow(800, 600, "Шестиугольная призма", NULL, NULL);
    if (!window) {
        glfwTerminate();
        return -1;
    }

// Установка контекста OpenGL
    glfwMakeContextCurrent(window);

// Цикл отображения окна
    while (!glfwWindowShouldClose(window)) {
        // Очистка буфера цвета
        glClear(GL_COLOR_BUFFER_BIT);

// Ваш код для отображения шестиугольной призмы

// Обновление окна
        glfwSwapBuffers(window);

// Обработка событий
        glfwPollEvents();
    }

// Завершение работы GLFW
    glfwTerminate();

return 0;
}

Шаг 2: Отображение шестиугольной призмы

Теперь, когда у вас есть окно и контекст OpenGL, вы можете приступить к отображению шестиугольной призмы. Для этого вам понадобится использовать функции OpenGL для создания и отображения геометрических фигур.

Вот пример кода для отображения шестиугольной призмы:

// Отображение шестиугольной призмы
void drawHexagonalPrism() {
    // Задание координат вершин шестиугольника
    GLfloat vertices[] = {
        0.0f, 0.0f, 0.0f,  // Вершина 1
        1.0f, 0.0f, 0.0f,  // Вершина 2
        0.5f, 0.866f, 0.0f,  // Вершина 3
        -0.5f, 0.866f, 0.0f,  // Вершина 4
        -1.0f, 0.0f, 0.0f,  // Вершина 5
        -0.5f, -0.866f, 0.0f,  // Вершина 6
        0.5f, -0.866f, 0.0f  // Вершина 7
    };

// Задание индексов вершин для отображения граней
    GLuint indices[] = {
        0, 1, 2,  // Грань 1
        0, 2, 3,  // Грань 2
        0, 3, 4,  // Грань 3
        0, 4, 5,  // Грань 4
        0, 5, 6,  // Грань 5
        0, 6, 1,  // Грань 6
        1, 2, 3,  // Грань 7
        1, 3, 4,  // Грань 8
        1, 4, 5,  // Грань 9
        1, 5, 6   // Грань 10
    };

// Отрисовка граней шестиугольной призмы
    glEnableClientState(GL_VERTEX_ARRAY);
    glVertexPointer(3, GL_FLOAT, 0, vertices);
    glDrawElements(GL_TRIANGLES, sizeof(indices) / sizeof(indices[0]), GL_UNSIGNED_INT, indices);
    glDisableClientState(GL_VERTEX_ARRAY);
}

// Отображение сцены
void renderScene() {
    // Очистка буфера цвета
    glClear(GL_COLOR_BUFFER_BIT);

// Отображение шестиугольной призмы
    drawHexagonalPrism();

// Обновление экрана
    glfwSwapBuffers(window);
}

int main() {
    // ...

// Цикл отображения сцены
    while (!glfwWindowShouldClose(window)) {
        // Отображение сцены
        renderScene();

// Обработка событий
        glfwPollEvents();
    }

// ...
}

Шаг 3: Запуск программы

Чтобы запустить программу, вам понадобится установить и настроить необходимые библиотеки и компиляторы. Вот пример команд для компиляции и запуска программы с использованием GCC:

g++ main.cpp -o hexagonal_prism -lglfw -lGL
./hexagonal_prism

После выполнения этих шагов вы должны увидеть окно с отображением шестиугольной призмы.

Обратите внимание, что код, представленный выше, является примером и может потребовать дополнительной настройки и оптимизации для вашей конкретной среды разработки и операционной системы.