Ответ:

Может мой ответ удалят, так как он неверный но 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

}

}